Building Intelligent Research Agents with Manus - Ivan Leo, Manus AI (now Meta Superintelligence)

Yeah, I think I can just start. So the way this workshop will just be run is we'll show a few demos of what we build with Manus, what we have at the moment. And then if you guys have any questions at any point in time, feel free to stop me. Throughout this whole workshop, what we're going to be using is the new Manus API. And it will go, basically, we'll reproduce our

original Slack bot. So if you use our new Manus app, you can actually now use Manus in Slack. So hopefully it works. Since I'm doing it live, I'm a little worried. But let's see. So I think a

little worried. But let's see. So I think a common question that a lot of people are asking is what is Manus and what does Manus actually do, right? Which is quite fair because at this point, we kind of do everything. If you go to our website, you see this really long description

that says, Manus is the action engine that goes beyond answers to execute tasks, automate workflows, extending human reach. If you search for what is Manus and the new announcements that we've made, you may have seen Manus 1.5, Menace 1.5 Lite saying that we're now faster, there's an increase in quality gain, some user satisfaction increase,

and then we've re-architected our models. Or you might just see in a lot of stuff that we talked about where we talked about the fact that building AI agents is just really difficult, right? And it's something we've learned as we scaled the number of conversations that we have every day to millions and beyond, right? Because now we have things like infrastructure, we have sandboxes, we have reliability and all these different considerations

to take care of. But really what we want to do at Manus is build a general AI agent that you want to use in a variety of different ways.

And we really want to meet users where they're at. And from day one, we've been designing Manus with this in mind. Whether you like to use Manus in your mailbox, whether you like it in Slack, whether you have your own custom programmatic workflow, or you just like to use the iOS app on the go, which I quite enjoy. We've kind of built Manus to do that. And because

enjoy. We've kind of built Manus to do that. And because

of that, we have a lot of different ways to use Madness. Currently, we have the web application. We have the Slack app. We have the API that we just launched, which we'll be working through today. We have a new browser operator. We have,

two days ago, we launched a new Microsoft 365 integration, which means that in the far future, in the near future, hopefully, when you're writing a Word document, or you're doing a presentation, or you're doing anything in the Microsoft Suite, If you just add Manus, we'll edit your PowerPoints, we'll fix your janky Excel templates, or you know, just whatever needs to be done. And lastly, we also have

MailManus. And so I've just been walking through four different demos that we built with

MailManus. And so I've just been walking through four different demos that we built with Manus, and you can kind of see what we've been building for the last few months since we launched Manus 1.5. One of the things that I... Let

me see if this works. Right. So I've been learning French for about a year.

And honestly speaking, I'm pretty bad at it. It's not an easy language. And what

I really wanted to do was to find a way whereby I could practice it every day. Well, I just managed to build me an application where, you know, I

every day. Well, I just managed to build me an application where, you know, I could practice this. And so the way it works is that, you know, throughout my day on my phone, I'm just going to key in a bunch of random prompts or random things in mind. Like, hey, today I had this thought. Today I'm stressed about this workshop that I'm currently conducting. And once you key this in, Manus then

takes a language model and finds the exact problems with what I've written. For example,

over here, you can see that there's an inline correction here whereby, you know, life is lived forward but understood backwards, right? And Manus is nice enough to give me an entire corrected version. But let's say, for example, I don't quite know what this word means. Well, I can just add it over here and say, what is defy?

word means. Well, I can just add it over here and say, what is defy?

Right? And this is because every single Manus web application ships with a fully featured language model that you can call, whether it's structured outputs that you want to use, whether it's whispered to transcribe audio, or even in this case, just inline corrections with structured outputs. You can even integrate any sort of provider you care about.

In this case, I chose to use 11Labs because I have some extra credits. And

I hope this works.

So the beauty about this is that I didn't do a single thing. And actually,

the cool part that I enjoy is that as I'm interacting with this, it kind of creates a profile for me. It seems that you're 28 working at Manus where you build agents. And hey, like, you know, your strength is your willingness to tackle a lot of these abstract ideas. But you're really bad at anything related to distance and time, which I get. But the beauty about this is that with Manus, like

with Manus 1.5, you're able to build these really complex operations from scratch. And

I think that's pretty cool. I would never have bothered to code this up. Oh,

sorry. Was that part of Manus's settings or the app? So this was just me prompting Manus on the go as I was bored in between talks at AIE. So

yeah, so that's just me. I just told Manus, hey, can you keep in mind because, you know, I would say things about myself like, oh, I have a dog, whatnot. But in languages like French, you need to bear in mind what's your agenda.

whatnot. But in languages like French, you need to bear in mind what's your agenda.

You need to have all these agreements. And it's kind of nice when you get writing ideas on top that Manus gives every day or the language model we invoke every day that gives you suggestions on what to write. And so this is an example of what the new web development platform can do. Let me just back to my slides. So another thing that we can do is MailManus, where we can use

my slides. So another thing that we can do is MailManus, where we can use the app. So for example, if I'm using my phone, let me try to connect

the app. So for example, if I'm using my phone, let me try to connect it right now. So let's say, for example, here, let's say we connect to my phone, and we go, like, let's say I have a moron task at Datadoc, right?

And you can just do things like, maybe I just want to follow this to reply and just say, like, my keyboard is kind of disabled on the screen sharing for some weird reason. But basically, you're able to essentially take a lot of these tasks and get Manus to do them for you. And this is an example of how we're able to meet users where they're at. The newest one, which I

think is pretty cool, is our new browser operator. And so I think let me just boot up the Manus application. And so that's a good example we can say, hey, Manus, I'm currently at the AWS Hang 27 in New York. I would love to get a coffee after this. I'm jet lag from Singapore where I've flown over 20 hours. And I just want something really general, just a really simple coffee. I

20 hours. And I just want something really general, just a really simple coffee. I

just want to drop by and grab something. I'm not pretty. I kind of just want something simple, maybe an Americano, and that should be good. And so what you actually see is that AsManus is executing a lot of this with the new remote browser operator. It'll think for a while, it'll go through a bunch of different things.

browser operator. It'll think for a while, it'll go through a bunch of different things.

And it'll actually kickstart a browser tab on my computer that I've set it up on. So what this means is that for you, if you're using any sort of

on. So what this means is that for you, if you're using any sort of thing like LinkedIn, if you're using like, you know, your Instagram, you have all these like platforms, you're locked in that you can't access through a sandbox browser, like BrowserBase, this completely changes like everything that you're using, right? Because now,

oh, I got a management listen. Not bad. Manus, can you use my browser, please? Thank you. Yeah, so actually this, by right, Manus should have used a browser

please? Thank you. Yeah, so actually this, by right, Manus should have used a browser that I have on my computer. Let's give it a bit of time to run.

Yeah, and so this actually kickstarts a tab on my computer, right? And so for a specific task whereby you need to use these authenticated platforms, Just keep going. It's been a while for the

keep going. It's been a while for the computer to boot up. Yeah, so you can see that it actually opened a tab on my computer over here. It looked on Google Maps. It booted up. And what

we're seeing this actually mean is that what's really cool about this is you spin up multiple instances of this in parallel. So you can imagine for someone with a Mac mini running in your basement, all you got to do is just say every day a scheduled task, hey, man, let's use this. And it'll get it done for you. And these are all things that you can do through the API. Because we

you. And these are all things that you can do through the API. Because we

built a general AI agent first, and then web development capability second, we can also do some pretty crazy things. For example, if you look at this demo that I built over here. So one of the things that I found really confusing about the AIE is that there's a lot of different events. I kind of

want to make sure I hit all of them. I found the website a bit confusing personally. And so what I told Manus to do is, hey Manus, can you

confusing personally. And so what I told Manus to do is, hey Manus, can you go to the website? Can you look at the browser? Can you open a single event? And then can you scrape everything there for me? And so what Manus did

event? And then can you scrape everything there for me? And so what Manus did is that he actually scraped every single thing on the website, it put in the JSON file, and then it loaded it into this website for me. You may notice a very brutalist theme, and that's because I really like Chroma's website design. So everything

I built looks like Chroma to some degree. What you get out of this is that, let's say I am interested in 2026, the year the IDE died. Well, you

can see that the description has been scraped. I can add to my Google Calendar in one click. And I also have similar events over here. For example, if I'm interested in the year the IDE died, maybe I want to check out Amcore or AGI, the path forward. Everything that I did over here was just built by me prompting Manus because I was like, hey, I like this event. Anything else I should

pay attention to? Everything here? is because Manus can build in with external platforms such as Chroma. And all I did was give it a Chroma API key and open

as Chroma. And all I did was give it a Chroma API key and open AI key so they can do embeddings. And now we have this. Now, my favorite feature is that after starting everything that I'm curious about, I can scroll up. I

can go to my timeline. And then instantly, I see a list of everything over here that is happening for the day, custom to me. And so yesterday, I was really happy to actually check out the new talks by Will Brown They apply compute guys, which are really technical. And this is an example of what you can build with the web development framework that we've put together. We also have support for things

like Stripe, which because we ship with a full Docker image, you can install anything on it. Some of my favorite examples, if you've used anything a bit more complex,

on it. Some of my favorite examples, if you've used anything a bit more complex, you need a Redis queue. You can actually just install Redis on the web app and use BooMQ, and you're good to go. Stripe integrations, if you use a lot of other platforms, because they're not full Docker images, they're not full application, they're just giving you a nice front end, you're not actually able to do things like

webhooks or more complex integrations. But we can support that. And if you use our Stripe integration, for example, we automatically set up webhooks for you. We have ways to test it, right? Manus can receive the webhooks. And in the future, we'll be rolling out things like auto scaling, warm deployments, and all the important things that you need in order to essentially build a single MVP idea, right? You can integrate anything you

want. You can add any packages you want. And please don't abuse this platform, guys.

want. You can add any packages you want. And please don't abuse this platform, guys.

I kind of like my job. We've worked very hard to try to keep it good and cheap for everybody. But most importantly, it really is the fact that if you build a general AI agent instead of verticalized products, you can do so much more. And I think that's kind of what I'm driving at here. Imagine building this

more. And I think that's kind of what I'm driving at here. Imagine building this six months ago. I would have to build a web application. After I built the web application, then I need to set up my Chroma account. I need to get my Chroma on DB set up. Then I need to maybe find cloud code, boot it up. After I put it together, I now need to think about, hey, where

it up. After I put it together, I now need to think about, hey, where do I deploy it? With Manus, it kind of just works. And that's kind of the beauty of it. And things will get better, right? So I talked a lot about what Manus is. And so I guess I should move on a little bit to the Manus API, which is what most people came here for. And so what

is the Manus API? Well, earlier you've seen a few different examples whereby you've used Manus to build websites. We've used Manus to do things like remote browser operation. And

Manus also ships with the ability to query things like the Notion, your custom FTPs, whatever sort of coding and written, because every single Manus chat ships with its own sandbox. And so you get the exact same things with the API. So what

sandbox. And so you get the exact same things with the API. So what

are some things that we build internally? The Slack bot is the thing that's public facing. Our Zapier integration is built on our API. Our N8N integration is also built

facing. Our Zapier integration is built on our API. Our N8N integration is also built on our API. And we built a lot of our own support bots in-house whereby before anyone looks at it, if it's something that's important, Manus can go to the chat, click on every single message, and at the end, it gives a full report with screenshots because it has a browser of everything that you can do. And

so I really liked what I built internally. And so I thought, why don't we build it together, right? This is a very complicated and I kind of hope Stripe and Moto work nicely. So we'll see, hopefully, fingers crossed. But through this, we're going to work through a lot of the simple ideas. We'll be looking at a few different notebooks. If you want to sort of see the notebooks, I have them over

different notebooks. If you want to sort of see the notebooks, I have them over here at this link. So tinyurl slash Manus API workshop. And so in order for you to get started with that, you'll need a Manus API key. If you

have a normal Manus account, the billing for the API is exactly the same as if you took a chat. So whatever you would spend for the same query in a Manus chat on a web app, the API would cost the same. And really,

for now, this is what we want you to do because we want Manus to meet you where you're at. We don't want you to have to worry about if I use the API, is it more expensive or less expensive? Is the chat different?

Should I use the Slack integration? We want you to be able to, we want to provide a customizable way for you to be able to work with Manus. And

so this is the tiny URL link. And I'm just going to proceed on to the next bit. So the first thing we're going to do is going to look at some of the API fundamentals. So I have the API over here. You need

these three environment variables. I've tried to make it very easy for you to set up Slack, even though it is a pain in the ass. And so here are the five notebooks that we're working through. If you scroll down a fair bit, I have these screenshots on how you can actually get your own Slack tokens. So let's

begin. So the first thing that you need is basically a managed API key.

And once you have the API key, you need to put it in this .env

form. I've provided basically the env variables you need in a .env.example.

But you basically need a managed API key, a Slack bot token, and a Slack signing secret. So let's load it in. I kind of need to.

signing secret. So let's load it in. I kind of need to.

Holy shit, those are. So you can see that now that we've loaded it in from our EMD file, let's test it out. So

we're just going to check what files we've uploaded prior to this. And because this is a fresh account, we haven't uploaded any files. You're just going to get object lists. If not, normally you have a data property. And so this means that our

lists. If not, normally you have a data property. And so this means that our API key is working as intended. One of the benefits of using the Manus account is that we often have a lot of clients that come to us saying that I have sensitive files. I have things that, you know, I want to make sure no one else is able to see. And so every file that you upload to

the Manus API, Files API, is basically going to be deleted automatically in 48 hours.

And so that means that whatever sort of temporary file you're using, if you delete the session, you can delete the file at any time. But if you forget like, oh, I upload this file, maybe I want to use it later, we will delete it for you. but you have to delete the session for the file to be gone. OK, cool. So we validated that the API key works. So let's create our

gone. OK, cool. So we validated that the API key works. So let's create our first task. I'm just going to be using the pure request here, where I make

first task. I'm just going to be using the pure request here, where I make a call request. But in our documentation at open.manus.ai, we do also have support for things like the OpenAI Responses SDK, if that's something you're using. If you're using any sort of AI framework, I've heard a few at this conference, like AI SDK, Copilot AG UI, or something like that. There are a whole bunch of them. These will

be if you reach out to me. I'm happy to try to see how we can make that work. So let's try our first query. Let's ask

Manus, what is 2 plus 2? Please provide a brief answer. So let's run it.

And when you run your first Manus API task, you see that you get a few things back. You get a task ID. You get a task title. And you

also get a task URL. And so these three things are really important, particularly the task ID. The reason for that is that when you interact with Manus and you're

task ID. The reason for that is that when you interact with Manus and you're using Manus as part of your workflow, part of your application, you might get things where Manus will ask you for certain bits of clarification, like, I'm sorry, I need to understand a bit more. What do you exactly want? Or it'll come back to you with some sort of data, and you want to actually get some follow-up feedback.

And so by keeping that task ID around, you're able to push to the same session. So let's get a bit on this task title that we've

session. So let's get a bit on this task title that we've gotten back. And

gotten back. And I need to, oh, did I use the wrong API key? I think I used the wrong API key, guys. I'm sorry. I will load a new API key for myself. I think it's this other one. Yeah.

myself. I think it's this other one. Yeah.

Yeah, so you can see what is 2 plus 2, and then you got 4, right? So this is the, basically, when you don't specify a chat mode, we have

right? So this is the, basically, when you don't specify a chat mode, we have a router on the back, and it tries to determine if you need to use basically simple chat or the full-fledged managed agent. And I think this is something that's pretty simple. But if you want full fine-grained access, those are parameters you can set

pretty simple. But if you want full fine-grained access, those are parameters you can set on the API. So if you've looked at the agent profile, basically the profile, the payload that we sent over, you may notice this agent profile, Manus 1.5. We talked about it briefly at the start, but there are two

kind of models that we currently use in Manus. One is Manus 1.5, and one is Manus 1.5 Lite. For a lot of these more complex tasks, we highly recommend using Manus 1.5. For example, both of the websites earlier were coded 1.5. If you

have very simple queries, things that you want to execute a bit faster, we recommend 1.5 Lite. So for this workshop, we're going to be using 1.5 Lite because we

1.5 Lite. So for this workshop, we're going to be using 1.5 Lite because we want a faster response, but also a lot of the things that we are working with are not that complex. And so with this new agent, you have a lot of things like unlimited context management. So what that means is that once you go beyond the sort of length context window of a normal model itself, like whatever

model we're using under the hood. We do a lot of smart context management. And

because for us, we design matters, we try to make sure that the KV caching is very high. If you read our article on context management by Peak, our CTO in June, this means that for you, the responses are fast and quick. And so

the easiest way is just to say, you can just pull matters, right? So let's

start another task. Look up the weather in New York City and then ask me a question about it.

So you can see that the task was created successfully, and you get a task ID, a task title, and task URL. Now, if you want to just pull this, it's pretty straightforward. There are basically three states that the managed agent can be in.

They're going to be either running, pending, completed, or error.

Ideally, you never see error. Error is a very rare case. You also have completed.

That means the managed agent is done. Pending is when it requires more input from you. Currently we're polling over here and we're seeing that the task is still running.

you. Currently we're polling over here and we're seeing that the task is still running.

Progress of this task, take a look at it. The water in New York City over here. So Manus is currently waiting for a response from us. So I've looked

over here. So Manus is currently waiting for a response from us. So I've looked up the weather forecast. My question for you is given the rainy forecast for Monday or Tuesday, would you prefer to plan an indoor activity or an outdoor activity for one of those days? So we see here's what you get back when you actually query the information on the task. You get the credits you've used. you get the

response back. This is sort of similar to your OpenAI responses SDK, but basically we

response back. This is sort of similar to your OpenAI responses SDK, but basically we expose everything to you. And so you get back basically your messages and the messages that Manus sent to you. And so let's say in this case, if you look at the original chat, Manus said that given the rainy forecast, would you prefer to plan an indoor activity or an outdoor activity for one of those days? And if

so, which day and what kind of activity would you prefer? Well, I guess in this case, I guess I'll I guess I'll prefer an indoor activity on Tuesday.

Probably choose probably an indoor activity on Tuesday. So we

let it run for a bit. And you can see that the same sort of message was pushed to the same chat. And what this allows you to do is ensure that as you're running more and more complex workflows, you're able to ensure that all of your context is kept within the same chat. And so you can use the same polling interval. This is a very simple pattern. As you're prototyping the Manus

API, polling is the easiest way to get started. And then in the third notebook, we're going to look at basically how to use webhooks. But for now, I think polling is pretty straightforward. You basically just check to see what is the current status of the task, given the four sort of statuses that we talked about, running, pending, completed, and error. We take those, and you can determine what to do next in

your application. So this is essentially the first core mechanic of the Manus API.

your application. So this is essentially the first core mechanic of the Manus API.

We talked about authenticating your connection to the Manus API. creating your first task, managing the entire asynchronous lifecycle from running a task, really doing the initial polling. And then

we also talked about how to push to the same task. So what's really important when you work with any sort of language model is you need some sort of context. Sometimes there might be a PDF of your policies. Sometimes there might be

context. Sometimes there might be a PDF of your policies. Sometimes there might be some sort of system you want to upload. So we have three different ways to do so in the Managing API. As usual, I've defined a small library over here.

env.py that does basically the same things that we did in the previous notebooks. So

you can see over here, all we do is we just test given a files API, and then we return the env key. So let's see how this works. It's loaded in first. So now we have our

this works. It's loaded in first. So now we have our API key and the base URL loaded in. So what I really love watching is Rick and Morty. And for a long time, it was one of the funniest shows that I enjoy. And actually, they have a free API. And so what we can do is we can grab the first maybe 100 characters from Rick and Morty. And

let's get Manus to figure out what exactly Rick and Morty, how their characters have been. So we fetched everything. And we can just save it to a rickandmorty.json file,

been. So we fetched everything. And we can just save it to a rickandmorty.json file,

right? Rickandmorty.json. So this is kind of how it looks like. We have every single character. We have the episodes that they've been alive for. And over here, you have

character. We have the episodes that they've been alive for. And over here, you have Morty. You have Rick's status. And you have the origin, their current location, and a

Morty. You have Rick's status. And you have the origin, their current location, and a short image about them. Right? And so with the Manus API, we support file uploads. And this is much more useful if you have sensitive files, files that are much larger than normal. And so what we basically do is, if you give us an API key, if you send a request to us, and

say, hey, I want to upload a file in this case. It's called Rick and Morley correct this. What we're going to do is we're going to check on our database. We're going to save it. And then we're going to give you an SG

database. We're going to save it. And then we're going to give you an SG link. And so what this allows you to do is be able to upload much

link. And so what this allows you to do is be able to upload much larger files. Now all you gotta do is do a put request. So we've created

larger files. Now all you gotta do is do a put request. So we've created this file and you can see the file ID, file jq, you get a file ID to start the file basically. And then we're gonna tell Manus, using the attached Rick and Morty correct dataset, let's create a simple and visually appealing website. And so

we've uploaded the file and let's take a look at the Manus website over here.

I think it's in my other account. Yeah, so you can see over here that basically Rick and Morty, we've uploaded the file. If you upload any images, any PDFs, we already come out of the box for things like targeting a PDF, handing all the multimodal content. So that's really useful for you, right? So Manus is going to run. It's going to create its website. We'll check

right? So Manus is going to run. It's going to create its website. We'll check

back in a bit. But this is basically the first Files API. And if you have large files that you might want to automatically delete it at some point. This

is a really useful way to do so. The next way that you can do so is you also have the ability to delete this file at any point in time. And this is an API call that you can run. Next way you can

time. And this is an API call that you can run. Next way you can do so is if, let's say, you're using a URL attachment. A lot of times, you might have a URL that comes from something like circleback. You've just done a call. You have a transcript. You want to send it over to Manus. And so

call. You have a transcript. You want to send it over to Manus. And so

we actually do support raw call transcripts. So what I've done is I have basically created a fake transcript. Yeah.

So I think this file was deleted by me accidentally. All's good. Warren

Buffett.

So thankfully, Berkshire had a bunch of investor letters.

And so we can just provide a PDF link. So

instead of a transcript, maybe this, we're just going to just do like Warren Buffett.

this should work. This works. And then maybe we want to, at this point, we want to analyze, given this investor letter that we have, can you help me parse out, can you help me summarize it and give me some insights into what the company is looking

to do? Right?

to do? Right?

So now we can start a task that automatically out of the box works with these public URLs. One of the things that I actually wanted to show over here is that with a lot of these basic tasks, any of the connections that you have in Manus, for example, Gmail, Notion that you've already configured ahead of time, these all work out of the box. And all you need to do is basically go

to Manus. Let's say our website is over here. You look at the connection

to Manus. Let's say our website is over here. You look at the connection over here. If you go to Manage Connectors, you can use any of these connectors

over here. If you go to Manage Connectors, you can use any of these connectors just by copying this UID over here. If you copy the UID and you add it as part of the connectors payload, it will work out of the box for you. We also support things like basically four. So this example over here, we

you. We also support things like basically four. So this example over here, we just had a simple forward forward page. This was a screenshot that I took of a page that Manus created. And so what we want to do over here is create an automated bug investigation task. Our users reported that the settings page isn't working. Let's give this base 64 encoded image to Manus, and let's

see how we can figure it out. Can you beat Dara? Here's a website that we've created ahead of time. And can you figure out what exactly are the problems with this? So this is a simple Manus web app that I've created.

with this? So this is a simple Manus web app that I've created.

Actually, if you go to the settings page, you get a 404. There are also other few pages that also have 404s. So let's see how Manus performs in a bit. So if you look at our Rick and Morty corrected data set, managed to

bit. So if you look at our Rick and Morty corrected data set, managed to sort of characterize all of this in a pretty cool website. You have the gender distribution, you have male, female, unknown. Rick Sanchez is obviously alive, as is Morty, since it's Rick and Morty. And you have all these other characters that are uniquely sort of characterized and visualized over here. For a lot of these internal tools, you can

imagine that if you have a lot of data you want to turn through, you can create a simple website just to visualize all of them out of the box.

And that's pretty useful. Similarly for this investor letter, you can see that We uploaded it, and Manus actually detected that even though I called it call transcript.json, it

looked at the file as a PDF, not a JSON text. And then it completed an analysis of Warren Buffett's investor letter, and it gave this whole analysis at the end. One pretty cool thing is that we can take this simple,

end. One pretty cool thing is that we can take this simple, we have the task ID, and so we go back to basics over here. Previously,

we had a thing whereby Sid You go to requests.url.

Let's see, I think, let me just grab this here instead.

This is not working as I thought it would. What I wanted to show was actually that if we go to this specific one over here, if we go to Manus, it will actually return. I

just want to show like the JSON.

So actually, if you look at the output over here, you notice that over there, Manus created a markdown file. And based off the markdown file, you get back the full file URL, the file name, the mine type. This is really useful if you want to do some sort of processing down the line with it. And so with this, we've covered things like how to use the files API. We've looked at basically

how to use publicly available URLs with Manus. And we've also talked about how to basically be able to use basically for encoded images. And so let's think a bit about webhooks. In the previous example, we created a task with Manus, we uploaded some

about webhooks. In the previous example, we created a task with Manus, we uploaded some files, and the way that we tried to determine that the thing was basically completed was that we hold it every 20 seconds. As you're scaling out to more and more tasks, what you really want is what's called a webhook. What a webhook does is that when your task is completed, we'll send you an API request, and that

will basically notify you that the task is done. So a really easy pattern over here is that you want to wait for the task to be completed, you get the webhook, and you get all the information about the current task. So in this case, this is really useful because if you're building any sort of complex application, if you want to use this basket scale, it's not really viable for you to be

able to sit there and just keep holding the API. It's going to be a bit complicated and I think not the best practice for you. You're going to basically have a lot of workers doing. But if you use webhooks, this is a much more sustainable way for you to do whatever sort of agent you're building at a much cheaper cost. OK, so I'm going to just use model over here. because it's

a bit simpler. I'll have the modal code on the right, and then I'll have the Manus notebook on the left. Let me just load up my virtual environment.

And basically what modal provides is it provides you the ability to deploy simple like Python applications. In this case, it's a fast API endpoint. And so

modal serve server.py. So what you can see if you run modal server.ty

is that we now get a public endpoint that we can use. And this is pretty straightforward. If you run it on your own computer with modal, if you set

pretty straightforward. If you run it on your own computer with modal, if you set up an account, you get $5.3. This basically gives you an endpoint that you can now hit. And so let's get the, oh, I think someone already hit my endpoint.

now hit. And so let's get the, oh, I think someone already hit my endpoint.

That's a bit stressful. OK, guys, please be nice to my endpoint. But you can see that over here, in this over here. Oh, wow, another person sitting in my endpoint. All right, guys, anyway. Maybe it's streaming in. That's kind of awkward.

endpoint. All right, guys, anyway. Maybe it's streaming in. That's kind of awkward.

But anyway, yes. So if you basically want to register an endpoint, webhook with Manus, and you register a webhook with us, when a task is created, when a task is stopped, we will send you two webhooks. And what this allows you to do on the front end is that then you know when you send a request to us, when have we started processing your task, and when your task has been completed.

The typical Manus task is going to take roughly three to five minutes, and if you have something that's a bit more complicated, this is going to be you're not going to want to send and poll and so the webhooks are a good way to do so so let's see over here how we can mimic a webhook that matters to send over here you have a test payload message and i think that's

what people are running with my url and so um you can see now that this is a really useful pattern because if i'm building and i have like 100 managed tasks running at once right i don't want to keep pulling for all of them and so with a webhook i can easily receive a lot of these notifications as they're running So let's register this webhook with Manus. So

all we're going to do is basically post to Manus. You have a base URL that we have, api.manus.im. Let

me just double check. I think I have that. The base URL is api.manus.ai.

And so if you post that, then you will register a webhook successfully. And in

this specific case, the webhook we want to register is this one over here. You

go to the Manus Connector setting, over here, Integrations, Build with Manus API.

You see that this is, it will appear basically over here, the new web book that you've registered. And so whenever you create a task, you will automatically send you a notification over there. So let's create a simple task. And oh, people are still sending me. And so let's create a simple task. And

sending me. And so let's create a simple task. And

then, Try to get it working.

So we've created what is 2 plus 2, provide a brief answer. This is over here. We've seen that the task is running, and it's just going to think a

here. We've seen that the task is running, and it's just going to think a little. Then it kind of just runs like echo 2 plus 2, VC, or whatever

little. Then it kind of just runs like echo 2 plus 2, VC, or whatever that is. And then it will send you an answer. And so you can see

that is. And then it will send you an answer. And so you can see over here that now that the task is completed, you get the full payload over here. This is kind of what it looks like. And if, let's say we paste

here. This is kind of what it looks like. And if, let's say we paste this.

But basically, you get back at this point, you get the ID that you have.

So what this means is if you have multiple managed tasks that are running, you can identify them by the task ID. You can also get back the current task URL. You get the output of it. In this case, the status is completed. We

URL. You get the output of it. In this case, the status is completed. We

sent to Manus, what is two plus two? Please provide a brief answer. And then

we said, let me calculate that for you. And people are really running it quite a fair bit. And so now that we've actually processed the WebPoker notification, what we might want to do is we want to just get the entire conversation history. And so to do so, we can set a simple secret over here.

conversation history. And so to do so, we can set a simple secret over here.

And so what this allows you to do is that when you're running your modal server, you basically are able to make a request to the Manus API and get back a list of every single chat message that's been happening in there. I've done

this ahead of time. And so we can just put this over here.

So all this does is that if it's done, it just gets a full request and it gets to task details. And so what you saw over there was basically what happens when we do this ahead of time. So now let's So that is basically webhooks. So right now, we've looked at how to create a task. We've looked at basically how to upload files. And then we've also covered how

task. We've looked at basically how to upload files. And then we've also covered how to use a webhook. So let's now look at basically how to use Slack, which I think will be a lot more fun. In the previous notebook, we looked at how to use webhooks. We're going to start integrating on Slack. I've created a Slack workspace for myself. It's just on Ivan Personal. And so in this small channel over

here, we're going to basically start interacting with our managed chatbot. So

first thing you want to do is you want to make sure that you have your Slack signing secrets. These are basically, I have instructions on the readme on how to get the bot signing secrets. Then you want to basically test it. Slack writes

a off test. So an Ivan personal for the bot money. You can basically test to see that your secrets are working as intended. And so this is really important because if your environment variables are not correctly set up, then you're not going to be able to do this. OK, cool. Let's run this bit by bit. So

we're gonna just start by defining a simple bot over here.

It's gonna call this chatbot.py.

And so let's run modal serve chatbot.py.

And so when you run this, you'll find that what you need to do then is We've initialized a simple modal app. We've added some dependencies. We have to use Slack secret over here that we start ahead of time.

dependencies. We have to use Slack secret over here that we start ahead of time.

And then we just have a single endpoint up here that's called slash webhook slash slash. And so you will have something like this where you have like a simple

slash. And so you will have something like this where you have like a simple like endpoint that you can hit. And so in my case, this will be the endpoint that I have, right? And so you can see that if we hit this endpoint over here, it takes a while to run. but basically get back status okay. And so what this

means is this is a publicly available like an endpoint for you to hit. So

when you mention anyone in Slack, for example, over here, before our bot is configured, if you just send bank money, like what's up, you're gonna get a message from Slack. Similar to how the managed API worked, you're gonna get a web hook with

Slack. Similar to how the managed API worked, you're gonna get a web hook with some sort of payload. And this enables you to essentially be able to look at the input, and you're gonna get something like, So you're going to get some sort of information from Slack, right? So we have this over here. Let's go to Slack, API.slack.apps.

API.slack.apps.

So we want to just make sure that, so previously we made sure that the Slack, that our server was able to receive a response. And so the next step that we're going to do is we're going to make sure that our server is able to be registered as a web on Slack. When you actually make a request to Slack, you need to make sure that when you respond, you actually get back,

you give back a challenge URL. So this is what you can see. We'll just rerun this. And we have this URL over here. And then

can see. We'll just rerun this. And we have this URL over here. And then

we're just going to put inside the event subscription.

Right, so this is verified. And what happened was that Slack basically sent us an API request, and we were able to successfully respond to it with a challenge. And

so if you see like a verified over here, you just need to save the changes, and that should work.

Once we've done this, we mentioned our bot in Slack. Let me just check.

We should get a API request from Slack. And so you can see that this was the mention over here. So over here, I said, add money, what's up? And

over here, you see, here's a text, what's up, right? And what you find is that if you just get the raw text, you're going to get the user ID.

And that is something that you want to parse out in the response. Cool. So

let's try to figure out how to respond to Slack over here. I'm just going to copy and paste this entire Slack event that we previously had.

So I'm just going to paste the Slack event over here so that we're able to a bit for context. And when we want to send a response back to the site, what we need is basically the channel that was sent in, the thread TS. And so that's how Slack identifies the right item. And

so let's get it from, you can basically get it over here. So you want to get the channel. Then you want to get the event TS, right? So let's send a response. And you can see that in Slack over here, we got a response that

response. And you can see that in Slack over here, we got a response that said, hello world. And so this is really kind of how your application will work.

If you're building a Slack bot, you get an API request from Slack. And then

once you get the API request from Slack, do something, and then you return it back. One of the things to note when you're building on Slack is just that

back. One of the things to note when you're building on Slack is just that you need to send a response in roughly like three seconds. If not, they're going to try again. And so if you're building any sort of Slack bot, you want to ideally keep some sort of server warm. So

let's try again to maybe, you know, in this case, we're going to send some files over here. So let's say we want to send the Berkshire Hathaway 2025 investor level. Well, with Slack, what you can do is you can basically just upload the file first. And so let's try uploading it to the right channel.

And let's upload it here. So now we have it uploaded to the channel. We

have an ID. And we can actually post the same message over here. So I've added. So previously, you saw that we got a Slack file ID.

here. So I've added. So previously, you saw that we got a Slack file ID.

And then when you have the Slack file ID, when you post the message, you just upload a file. We get back a list of file IDs. And that is included as part of the attachment itself. And so let's say over here, we've got to take this to the channel that we previously used.

So if you look back at this chat over here, you can see that we sent, we essentially first one over here uploaded it to the channel. And then the second one at the bottom over here basically sent the same thing over there with HelloWorld. One of the problems you find over here is that we actually didn't upload

HelloWorld. One of the problems you find over here is that we actually didn't upload it to the right thread, right? We uploaded it to the channel. And so when you're working with files in Slack, you need to make sure that you keep this in mind. And so this is basically how you work with files in Slack. And

in mind. And so this is basically how you work with files in Slack. And

so let's now try to get Manus involved over here.

So now we're gonna build Slack integration.

Obviously up ahead, we had these functions over here. And so we can just use them to add it in.

I'm gonna add this Slack message over here. Using at my turn event, that's from the Slack SDK.

So we previously defined a function called post Slack message. And so let's make sure that we have that running.

Then we had a bunch of different helper functions up here. So let's make sure that we also copied them.

So data class is not defined. All I need to do over here is just define a data class. Then file ID.

So now that we've added in a whole bunch of these different things that we previously had, let's see how this works on the main Slack version. We're going to just add this full portion up here.

So with this, what our goal is to basically to reproduce what we did in the notebook manually. So let's try to see if this works out of. Manus C

group is not defined.

So now that we've started up, then We had a small bug over there. And so, you see what we did in the previous portion was that we tried to basically get Slack working with a web.

And so, what I did wrongly was just that if I identify the managed URL, and so let's just have it run over here.

So you can see that now we have a response of what we did manually, just copying it bit by bit, right? And so, with this, we've now figured out how to basically work with Slack. If I send a message, I can get a webhook, and I can process it with my modal server. This is a really simple sort of approach, but it's really useful when it comes to doing anything else. You

can imagine that for you, if let's say you're doing some sort of complex processing, you might get the user's information, get some sort of metadata from the user, fetch the prior conversations with the TV, and then actually start sending the task over to Manus to start executing. So let's all see how we can actually get this running with Manus. I have a function over here called create a Manus task. It does

with Manus. I have a function over here called create a Manus task. It does

something very similar to what we did previously, which was that we'll post a request to Manus. We would have a JCPen environment variable that we would send it along

to Manus. We would have a JCPen environment variable that we would send it along with. And then we would then, in this case, just send a prompt. So let's

with. And then we would then, in this case, just send a prompt. So let's

test it out. Create a Manus task. And then instead of this over here, we're going to create a Manus task.

And then we're going to take in event.

like this and then we'll see if i'll create it successfully you can view it here so i'm just going to add a simple wake up function so that we can just wait this um so let me just go back to the web app sure it's running it's woken up and then let's try to kick off a task in menace so

what's the status in new york So now we've got a post request. And Manus replies to the fact that, hey, we've created a task successfully with Manus. So let's take a look at this task and see how it's been. Tasks should appear inside here. What's the weather in New York? So one thing you've noticed is that we don't actually get the response. We

York? So one thing you've noticed is that we don't actually get the response. We

can send these current tasks over to Manus. We can pick some of these tasks off. But we don't get the response. So let's see how

off. But we don't get the response. So let's see how we can fix that.

So what we're going to be doing is we're just going to be checking over here. Let me go back. Sorry, guys. I'm just a bit stressed out today. OK, anyway, one thing that we saw just over there was that this is kind of an ugly setup. And so what we're going to be doing is just making it a little bit prettier. If you notice in the text,

you get basically the ID of the user. In this case, when I tag many, add many. So there was this really ugly section over here where it said, you

add many. So there was this really ugly section over here where it said, you look at the text, you get this 09FDL. If you use the Slack API, what you find is that you're basically able to get a list of all the users, and you can then do some parsing. You might have some additional data on what exactly that this user represents in a database. But over here, we're just trying to

make it a bit prettier for now. So we're going to update the post-slag. Post-slag.

post-slag. Post-slag.

So we're gonna just update this message over here.

Then you have a bunch of these different types. So we need to update them.

Then from typing, we'll just add optional. Then

the Slack response up here. It's like response.

We just need to import the Slack response so we get something that's typed and that should be. And so

now we post a message, we have blocks.

So we're just going to make this a little bit nicer over here with Manus.

And so what this means is that over here, Slack has this wonderful thing they ship called Slack Block It. So you can custom, if you've used a lot of these Slack bots previously, you'll find that they ship these nice little buttons. And so

you can actually do that out of the box with this thing called Block It.

So what we're doing over here is we're just going to add this thing called, we started working on our requests. And then we'll add the URL over here and a little emoji called ViewOnWeb. And the URL over here would just be the task URL that we have. And so with the post-like message, we can just add blocks to be blocks. And so since the blocks will

be sent over, I think we can see if this works. Let's hope this works.

And then I'm just going to go back and remove the original. Since we're no longer using the text, we can just use the box. And so let's remove that.

Let's wake up our server a fair bit over here.

Pick up our server, make sure it's running.

And then I'm just gonna ping. What's up?

Cool. And so there's an argument. So I just put ink over here and just put like text. What's created? I think we don't need a text over here because it's good to go. Yeah. Let me try it again. So this essentially, you can see that now we have a much nicer

it again. So this essentially, you can see that now we have a much nicer enriched sort of UI. And if you click on this, you'll be able to essentially see like a message over here. Hey, I'm Manis, I'm your friendly UI, friendly chat assistant, what do you need from me today? Cool. So with this, we walked through how to create a Slack task. Manus can now actually receive a message from Slack.

And so one thing that's pretty useful if you've looked at basically any of our Slack bot is that it can take multiple conversations. I send a message, Manus responds, I send another message. Yeah, so what you want to do is you want to just enable multi-turn conversations. And so the way you want to be able to do so is that you want a way just basically to store. If you've seen this

thread before, Because if every time you send a message and you want to post the same thread, you need to kind of keep track of that. And so what we'll be using over here is just a simple dictionary that modal ships with. If

you're using anything like Cloudflare, you can use like a KVStore. If you're using some sort of database, these are things you can load into the database. But that's basically what you can use out of the box. And so modal is a pretty good dictionary out of the box that we're going to be using. But I think it's good to get a rough sense for how it sort of works. So what we'll

be doing is just be adding two simple endpoints that we can use to post and set these requests. And so we'll be adding them to our actual server. Let me just fix this.

So we just need to make sure this demo tick is added inside this.

Yeah. Oh, cool. Now we have added these two new endpoints. And so we'll kind of get a sense of how the modal dig works before we actually start going into how to use it with the other chats. So over here, let's say when we get a chat, previously we talked

other chats. So over here, let's say when we get a chat, previously we talked about how you're going to get some sort of response. You get a task ID, you get a task URL. But we also kind of want to store things like what is the Slack channel? What is the Slack thread TS? What is the Slack user? What is the status of the current job, et cetera? And so by using

user? What is the status of the current job, et cetera? And so by using something simple like a dictionary where we can serialize basic key value stores, we're able to do this quite simply out of the box. So let's see over here.

Let's say we start a simple managed task, right? And we get back some of the task data. We get the, over here, we look at these stored value. We store the task. We just put a random, you know, like, task

stored value. We store the task. We just put a random, you know, like, task ID over here. And then we start like task ID, task URL, Slack channel, et cetera. But you can also get back when you retrieve this when you hit the

cetera. But you can also get back when you retrieve this when you hit the same endpoint, right? This gives you back what you want. And so this is essentially how the modal dictionary works, simple kvstore. And so that is a relatively simple way to use it. And so let's try to use this modal dictionary so that we can actually push to the same task, right? So let's first delete these two endpoints that we have.

And then let's create a new task map over here that we can basically store basically a mapping of a thread ID, thread tiers to a task.

So we already have the function to create the manage task. And so all we need to do is that up here, like what we mentioned earlier, when you actually mention a bot in Slack, you're going to get this weird thing. And so

what we want to do is we want to just basically parse it out.

So here's a simple function that we just parse it out. We'll then check in the thread map whether or not this thread ID has been seen before. And this

is because when we get the web book from Slack, we're going to see the thread TS. And if we've seen this thread before, we want to basically push it

thread TS. And if we've seen this thread before, we want to basically push it to the same task using task ID parameter. And if we've really seen it before, we're just going to add a simple reaction over here, which is just the eyes that you've seen a lot of Slack bots have. Hey, I'm on it. Notify it.

This works out of the box. All right, cool. Let us copy this.

All right, and then we have this new function called handleManageTask.

a Slack message. And so this will essentially replace what we previously had over here.

Cool. Let me see if this works.

We have a new server. Let's put it up again. Let's go to Slack, and let's just say, and Manny, what's up?

And then our server boots up. It will respond. You can see over here we created a new task for Shred ID. And then let's go into this task itself.

And we say that, OK, add many. What's

the temperature in New York? And so we push it to the same task. So task ID, create-task an unexpected one. OK, sorry, this is on me. So all we need to do is we just need to update the create-task over here. So it takes a task ID parameter.

What we want to do is we just want to take this JSON over here.

We're going to make sure that if, let's say, we provide a task ID, we add it to the JSON payload that we sent along.

Let's call it audit.

Let's give it a while for our server to restart. Let's boot it up again.

And then let's give this a shot. You could just send the same thing again.

Wouldn't push you. So this will hopefully, you can see that right now we have this reaction. That means that we've read from the dictionary. We've seen that this is a thread that we've seen before. And

basically what we do is we push it to the same task using this task ID. So let's take a look at the live tasks that's currently being executed. You

ID. So let's take a look at the live tasks that's currently being executed. You

can see that this is essentially with our first message. We then push it, the same follow-up message over to the same thread. And this allows you to basically be able to work with a lot of these simple integrations, like out of the box.

And so right now, one of the problems is that the final answer never makes it back to the user in Slack. What we need to do is what we did previously when we were basically working with webhooks is that when we get a webhook address from Mattis, we need to make sure that we push it, make a, essentially we post it back, right, over to the same thread and so that we

respond correctly. And so just give me a while, let me code it up and

respond correctly. And so just give me a while, let me code it up and then we can walk through the code.

And the last bit, we just need to upload the, let's just say upload files.

And that should work, hopefully. Upload files just need to be uploaded, so it also takes an A thread, yes.

Cool. So the entire, so then we just need to add the final endpoint. Sorry,

please bear with me for a bit. And then we can walk through the code for a while.

Cool. So with this now, we have a way whereby when Manus actually gives a response, it's actually able to respond to you. So let's try it out. And then

we're going to walk through the code of what we've exactly implemented step by step over here. So as usual, let's wake up the server a little bit,

over here. So as usual, let's wake up the server a little bit, and then we're just gonna say, Admani, what's up?

Right, same thing as usual, it's gonna hit our endpoint, and we're gonna create a new task, and we get a response over here, right? Start working a task, task ID is this, and view the live task. It's just gonna execute as usual, and then once it's had a response, should get back the webhook slack.

Let me just see what's going on. Should be getting back this response at webhook slash minus.

Let me just debug this for a bit.

I'm just going to bounce ahead over here. I feel like I'm encountering something with difficulties, but I just want to explain a little bit about what's happening. I'm free,

sorry. Basically, what's happening over here is that we have a simple Slack bot. And

as Manus is sending us a response, it's basically going to be able to have what we essentially are all of the different bits of markdown that Manus is giving and sending back to us. So this is really useful because a lot of times Manus will output markdowns such as tables, text, images, et cetera. And you really want to make sure that's rendered nicely. It's a bit complex in Stripe to be able,

I'm sorry, a bit complex in Slack to be able to do this. And so

what you have to do is do a bit of transformation. And so what we've essentially done, if you look at the notebook, is first, when we actually create a new task, we save it inside this task info map, right? We then convert it over to a Slack markdown format. And what this does is that it basically just passes the sound of the existing markdown. And so that it's compatible with Slack. Slack

has some unique markdown formatting issues. And so we just need to make sure it's consistent. And then we then take this markdown and format it into Slack blocks. We

consistent. And then we then take this markdown and format it into Slack blocks. We

then also, previously we had an upload file function. And what you notice that we uploaded a file, it was always uploaded to the main channel, but not to the thread. And so how you can solve this is by passing in basically both a

thread. And so how you can solve this is by passing in basically both a thread and a channel parameter. And so what this means is that when Slack uploads the file, it will go not only to the channel, but the right thread. So

this is really useful in that sense. So I think in the next portion, we're just going to try to implement it so that you can sort of basically have it a process in invoice. I'm just going to use the final code that I've written ahead of time so that in case of any technical difficulties again. I just

wanted to pause here and see if there's any questions about how to work with the API.

So let me just test to see if this is working. I

think I had a bunch of images that I gave previously. So I'm just going to take this picture of a bunch of bagels that I bought previously. I've been eating a lot of bagels since I've gone here. So it's pretty good, actually, because I was really surprised by how good

gone here. So it's pretty good, actually, because I was really surprised by how good a lot of the bagels were. But the other day, I feel like I got scammed a little because I ate a bagel that was like 90% cream cheese, like 10% salmon. And I was a bit sad about that. And so, yeah, so really

10% salmon. And I was a bit sad about that. And so, yeah, so really what this does is that if you look over here, the first thing that we get is you get a Slack web book. You create the file. You create the man as event. and then we're going to post a reply. And over here, you can say, hey, we've started working on your requests. If we go over to the

Manus app over here, you see that we have this thing called a connector. And

this is basically Notion that's out of the box. What I've done is that I've created, oh, sorry, this is actually, let me just create and go to the fake one.

Anyway, so we actually have a notion where we have these company policies. And I've

created a fake company policy for you to reference. And so what you see over here is you have all this information, like the company home, what exactly is happening.

And Manus is actually able to look at the notion, look at the connectors, and actually give a response for how exactly this is sort of related to my actual claims policy. And this is really useful if you're building anything related to some sort

claims policy. And this is really useful if you're building anything related to some sort of internal deep research sort of API because You're constantly going to want to be able to reference certain things that you have. You can see that the file over here was uploaded successfully. And then Manus is able to use OCR to basically extract all the details on the receipt. And some of the previous tests, you can see

that there were a lot of tests. You can basically see that, you know, I just spent $30 on cats in New York. It's a cupboard. And Manus is basically able to respond, look at the company policy that's in Notion, which anyone in your company can edit. Notion is a pretty accessible platform. And then they can take that and actually edit it out of the box. So as Manus is generating its response,

we're waiting for the final web book to be sent. And so let's give it a bit of time. Yeah. And so what you kind of expect to see is that if you give, let's say, can you help me update this basic invoice? Can

you find the shop details, please? Thank you. And then manager is going to ask, hey, can you give me a bit of updates? This one over here, you can see if you look at the invoice, what are the summary details, the merchant Tomkin SQ burgos, and what's the amount? Can you update it using a markdown table instead?

And it was basically able to go to the right page over here, realize that the exact receipt that I had was basically from dates of 18 to the 28th.

And then I was able to update the right Notion page and basically say that, hey, these are all of the different expenses. These are actually my expenses for the last few days. And you can break it down based on this fictitious company policy. So I think this was a bit of a more complex project. And

company policy. So I think this was a bit of a more complex project. And

I think at the end, there were some issues with live coding. But I just want to basically bring it back and try to say that Demandist API is basically a really easy way for you to build a lot of these complex applications out of the box, right? You look at the Rick and Morty dashboard that we had, you can see that this is pretty cool, right? And if you look at the,

let's go back to the slides. Let me slide somewhere.

Yeah, so A lot of what you can actually build out of the box with the Manus API is that these are things that we've done out of the box scaling the number of conversations that we deal with every day to millions of conversations. So

what this means is that if you use the Manus API, you do have the ability to use any sort of integration that we ship with. You can provide your own sort of keys. You can really just add any sort of custom code that you have, upload these files, toolkits for Manus to use. And this means that without you having to deal with all that you can actually focus on the core business

logic that you care about. And so if you have any API queries about the Manus API, feel free to reach me at IvanLiu at Manus.ai. And then if you're interested in joining the Manus team, we are hiring right now. And so feel free to reach out to me or just chat with me here. I'm happy to take any questions about the API. And thanks so much for taking the time to listen

to me. I'm curious how you think about educating people about all the possible use

to me. I'm curious how you think about educating people about all the possible use cases for the API and how to stitch all these things together to solve their problems? Because I imagine a lot of this is new to people and it doesn't

problems? Because I imagine a lot of this is new to people and it doesn't quite click immediately that, oh, I could use the Mattis API to solve my problems. Yeah, I think the easiest way to get started before you move to the API is actually to play with our web app. Because the web app has everything nicely set up. You don't need to do web hooks, you don't need to do integration.

set up. You don't need to do web hooks, you don't need to do integration.

And so a lot of times what I recommend doing is saying, hey, I have a problem or something I'm repeatedly doing. You look at basically the web app, you try a few times, and Manus can get it done pretty well. And then you want to start looking at the API, testing a bunch of these requests, seeing what you need to provide, what sort of context, and then getting that nailed down consistently.

I think that's how I would approach it. So you use a really simple way, a simple sandbox, and you use that to basically get started. Yeah. Is there any other questions that I can help with? Yeah, I can't hear it. I'm sorry. No, you can go ahead, man. So no question on the API,

it. I'm sorry. No, you can go ahead, man. So no question on the API, but can you tell us very quickly how you created that site? What were the steps, the conference site? You redid that, right? So if you can talk a little bit about that. Sure. I can show the managed chat, actually. I think that's more fun. Yes,

fun. Yes, maybe.

Give it a while for the site to load, I think. So we can see this is basically the full chat that's running. It'll take a while to load because there's quite a lot of conversations that need to be loaded up. But basically what I did is I just said, hey, can you start with this? Can you scrape all the events? There should be 70 plus talks, I think. Time is on EST.

Can you build a website that's clean, brutalist design, search bar at the top, add to calendar, star events, and make it work more well too. And actually I tried to use a bunch of Manus has a lot of cute emojis. But I tried to use a lot of these different services, like MixBread for a while. And then

I looked at Chroma, and then it just gave you API key. But really what you can see over here is that this is an iterative process where you're using Manus as a way to basically handle a lot of these complex edge cases that a simple agent might work out of the box for simple websites might not be able to do. And so after I gave it a set of events,

you can see Manus just a simple Python script. It converted all of the individual PM, AM stuff, whatnot. And it just converted it all to UTC. And then it just scraped everything in the end. And one of the things that was really cool that I saw was just that if you look at the page, I kind of

tried to expand... Scrolling,

scrolling, reading file. So basically, it ran a lot of JavaScript. It tried to match what it expanded. It read the HTML. And then from there, it was able to actually get the right set of events. And so I think over here, you can see a very specific use case I had in mind. I want to make sense of events. And I think the best way to work with a lot of these

of events. And I think the best way to work with a lot of these is just to have just try, see what the Manus agent can do, and then thereafter, try to put it together. Yeah. Oh, no.

Go ahead. You can ask. So thanks, Ivan. Amazing demo. Thanks for such a tidy and clean notebook. I'm going to go back and try it straight away in my own company because I'm meaning to support agents and this is an amazing demo.

I just want to ask, where does all this information, because it's all so sensitive, where does it live and can we get it deleted later or anything like that?

Sorry, what do you mean by what is this? Oh, like right now, who's reading my transcripts? I think when it comes to, if you say who's reading your transcripts,

my transcripts? I think when it comes to, if you say who's reading your transcripts, you mean all these chats? Yeah. So user privacy is really important for us. And

so for us, we can't read any of the chats. Yeah, the only chats we read are when you share with us, hey, Manus isn't working, and we go in and check it out. I think all of your data is housed in the US.

And so there's no worry about that.

Yeah.

I know you built this really cool page. what would be really cool, like if you could have those events, like put it in directly to your calendar. So, and

also my, another question was like, like what's the most interesting use case you've seen in Manus people using the Manus API or just a platform?

API is pretty new. So I think we're sort of like exploring and seeing what people are using it for. A lot of people are using it for research, trying to like really access a lot of like, to make sense of a lot of data. And I think that is basically leaning a lot of the advantages that Manus

data. And I think that is basically leaning a lot of the advantages that Manus has. In terms of the sort of advantages that Manus, I think the cool things,

has. In terms of the sort of advantages that Manus, I think the cool things, I really like Pickleball. I don't know if anyone here plays it, but it's pretty popular. It's really competitive in Singapore to basically get Pickleball slots. And you can only

popular. It's really competitive in Singapore to basically get Pickleball slots. And you can only book them through the government. It's a Singapore thing. And so what I got Manus to do is they wrote a Python script that spun up six Selenium instances and scraped the entire government website. And then they said, like, In two weeks, you can play pickleball at this location. And I thought that was pretty cool because I think

that's one of the benefits you get by using a general agent with its own sandbox, with its own ability to basically spin up these code to run it, to test it. And if you use the API, that's what you get out of the

test it. And if you use the API, that's what you get out of the box. Is it possible to use the MyBrowser through the API? And if so,

box. Is it possible to use the MyBrowser through the API? And if so, how would it determine which browser to use? Yeah, I think when it comes to MyBrowser, I think that... will be something that we'll look into. So my browser requires you to not only choose the browser, but also approve it, because you don't want to randomly spin up tabs on your browser. So we'll be working on basically improving

the permission system so you can do things like the, like, by research, the browser, and all these other bits of things that you need to authorize. Because user permissions is something that we want to try to think carefully about. And so we want to make sure we have it done well before we ship it off. But that's

in the roadmap soon. We also have, in maybe two weeks, you'll be able to, let's say Manus generates like a markdown or Manus generates like slides for you. They

will all be able to be converted to the same format you see on the UI. So what this means is that, let's say, you give Manus, say, hey, I'm

UI. So what this means is that, let's say, you give Manus, say, hey, I'm really interested. I would like to pitch my company. I would like to pitch something

really interested. I would like to pitch my company. I would like to pitch something to someone, right? Who does all the research, puts the slides together. And using the same API, you can download a full pptx file. You can export it however you want as a PDF. I think that's really useful. Or even like markdown to PDF.

And so we have a lot of these same features in mind to ensure feature parity so that you get essentially the same experience on the API and the UI.

That was really informative. Thanks very much. So my question is about, so if I'm doing some research on some topics, I don't want to always give it the background, the context in every conversation. Since it's linked to my accounts API keys, my question was if it's possible to remember, it's, you know,

you have like a memory or like for me to decide like in every conversation, do I want to, you know, remember, you know, just draw memory from like my other conversations or, you know, like a temporary mode, stuff like that. Yeah, I

think a memory is something that's really interesting. It's something that we're actively looking at.

And so I think for now, it's not possible, but maybe in the near future.

So for now, you have to be a bit more explicit when working with Madness, unfortunately. Yeah. Yeah. Are there any other questions I can help

unfortunately. Yeah. Yeah. Are there any other questions I can help with? Cool. If not, then I'll just be over here at the front.

with? Cool. If not, then I'll just be over here at the front.

We also have another colleague from Manus yesterday over there. If you need any help with the API or just asking questions about Manus in general, thank you so much for taking the time to listen to me today. And sorry about the technical difficulties.