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 would just be run is we'll show a few demos of what we've built 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 basically 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 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, extend human reach. If you search for what is Manus and the new announcements that we've made, you may have seen Manus 1.5, Manus 1.5 Lite, saying that we're now faster, there's an increase in quality gain, some user satisfaction increase, and that we've re-architected our models.

Or you might just have seen a lot of stuff where 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'll 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 of that, we have a lot of different ways to use Manus. Currently, we have the web application, we have the Slack app, we have the API that we just launched, which you'll be walking 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, well, 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 just whatever needs to be done.

And lastly, we also have Mail Manus. And so I'll just be 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.

So I asked Manus to build me an application where I could practice this. And so the way it works is that throughout my day on my phone, I'm just going to key in a bunch of random prompts, 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 whereby 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 defi,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 Whisper 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 11 Labs because I have some extra credits. And hope this works.

Avie doit être vécue en regardant vers l'avant, mais on ne la comprend qu'en regardant en arrière.

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, your biggest 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 the new 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.

Was that part of Manus's settings or the app?

So this was just me prompting Manus on the go as I was bought in between talks at AIE.

So you're a user person.

Yeah, so that's just me. I just told Manus, hey, can you keep in mind, because 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 gender, 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 go back to my slides. So another thing that we can do is Mail Manus, where we can use it for the app. So for example, if I'm using my phone, let me try to connect itright now.

So let's say, for example, here, let's say we connect to my phone and we go, let's say, I have a morning task at Datadog,right? And you can just do things like, maybe I just want to forward this to reply and just say, like,

I think 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,right? 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 let's say, for 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-lagged from Singapore, where I've flown over 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. Right, and so what you actually see is that as Manus 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, and it'll actually kick start 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 thing like LinkedIn, if you're using your Instagram, you have all these platforms, you're logged in, and you can't access through a sandbox browser, like browser base, this completely changes everything that you're using,right?

Because now, oh, I got it. Hey, Manus, listen. My bad. Manus, can you use my browser, please? Thank you.

Oh, yeah, so actually, byright, 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 kick starts a tab on my computer,right? And so for a specific task whereby you need to use these authenticated platforms, just

give it 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 pulled it up,right? 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,right?

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, Manus, use this, and it'll get it done for you. And these are all things that you can do through the API,right?

Because we built a general AI agent first, and then web development capabilities 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,right? And I found the website a bit confusing, personally.

And so what I told Manus to do was, 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 is that it actually scraped every single thing on the website.

It put it into a 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 build looks like Chroma to some degree.

But 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,right? For example, if I'm interested in the year the IDE died, maybe I want to check out Amcode 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,right? 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 OpenAI key so it can do embeddings.

And now we have this. Now, my favorite feature is that after starring 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 and the Applied Compute guys, which were 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, 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 BoolMQ, and you're good to go,right?

Stripe integrations, if you've used a lot of other platforms, because they're not full Docker images, they're not full applications, 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 autoscaling, 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. I kind of like my job.

It's been, we've worked very hard to try to keep it good and cheap for everybody. But most importantly, it's like, 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,right? 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 DB set up. Then I need to maybe find Claude Code, boot it up. After I put it together, I now need to think about, hey, whether I deploy it. But with Manus, it kind of just works.

And that's kind of the beauty of it. And things will get better,right? So I've 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 MCPs, whatever sort of coding you've written, because every single Manus chat ships with its own sandbox.

And so you get the exact same things with the API. So what are some things that we built internally,right? The Slack bot is the thing that's public 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 isn't very complicated, and I kind of hope Stripe and Modal work nicely with. 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 here at this link. So a tiny URL, /manusapiworkshop.

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,right? We don't want you to have to worry about if I use the API, is it more expensive, 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'll 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. And if you scroll down a fair bit, I have the screenshots and how you can actually get your own Slack tokens.

So let's begin. So the first thing you need is basically a Manus API key. And once you have the API key, you need to put it in this .env file. I've provided basically the env variables you need in a .env.example.

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

polish up those stuff. So you can see that now that we've loaded it in from our .env 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 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 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 uploaded this file, maybe I want to use it later, we will delete it for you,right? But you have to delete the session for that file to be gone. OK, cool. So we've 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 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. Please feel free to reach out to me.

I'm happy to try to see how we can make that work. So let's try our first query,right? 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. And 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 give some follow-up feedback. And so by keeping the task ID around, you're able to push to the same session.

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

And

I need to, oh, there is 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. Oh, 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 a router on the back end that tries to determine if you need to use basically simple chat or the full-fledged Manus agent.

And I think this is something that's pretty simple. But if you want full fine-grained access, we can, those are parameters that you can set on the API. So

if you've looked at the agent profile,right, 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 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 lang context window of the normal model itself, like whatever model we're using under the hood, we do a lot of smart context management. And because for us, when we design Manus, we try to make sure that the KV caching is very high.

If you read our article on Context Management by Peak or CTO in Tune, most of all, this means that for you, the responses are fast and quick. And so the easiest way is just to say, you can just pull Manus,right?

So let's start another task. Look up the weather in New York City and then ask me a question about it,right?

Yeah, 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 Manus 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 Manus agent is done. Pending is when it requires more input from you.

And so currently, we're pulling over here, and we're seeing that the task is still running. Progress of this task. Take a look at it. The weather in New York City 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,right? So we see here's all the, 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 the OpenAI Responses SDK, but basically, we expose everything to you. And so you get back basically your messages and the messages that Manus has 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 prefer an indoor activity on Tuesday. I'll 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. We've talked about authenticating your connection to the Manus API, creating your first task, managing the entire asynchronous life cycle 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,right? Sometimes there might be a PDF of your policies.

Sometimes there might be some sort of system problem you want to upload. And so we have three different ways to do so in the Manus API,right? 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. Let's load it in first. So now we have our API key and the base URL loaded in. So what I really love watching is Freak and Morty. And for a long time, it was one of the funniest shows that I enjoyed.

And actually, they have a free API. And so what we can do is we can grab the first maybe 100 characters from Freak and Morty. And let's get Manus to figure out what exactly Freak and Morty, how their characters have been.

So we fetched everything, and we can just save it to a Freak and Morty.json file,right? Freak and Morty.json. So this is how it looks like. We have every single character. We have the episodes that they've been alive for.

And over here, you have Morty, you have Freak status, and you have the origin, their current location, and a short image about them,right? And so with the Manus API, we support this thing. We support file uploads, and this is much more useful if you have sensitive files, files that are much larger than normal.

And so this, what we basically do is if you give us an API key, if you gave us, let's say, if you send a request to us and say, hey, I want to upload a file, in this case, it's called Freak and Morty characters.json.

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 S3 link. And so what this allows you to do is be able to upload much larger files.

And all you got to do is do a PUT request. So we've created this file, and you can see the file IDs. They say file JQ, you get a file ID that starts with file, basically. And then we're going to tell Manus, using the attached Freak and Morty character data set, 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.

Just check. I think it's in my other account.

Yeah, so you can see over here that basically Freak and Morty, we've uploaded the file. If you've uploaded any images, any PDFs, we already come out of the box to support for things like parsing of PDFs, looking at handling all that multimodal content.

So that's really useful for you,right? So Manus is going to run. It's going to create this website. We'll check that in a bit. But this is basically the first Files API. And if you have large files that you might want automatically deleted 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. The next way you can do so is if, let's say, you're using a URL attachment,right?

A lot of times, you might have a URL that comes from something like Circle Back,right? You've just done a 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. That was good. Warren Buffett.

That's still there.

So thankfully, Berkshire had released 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 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?

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 over here. If you go to Manage Connectors, you can use any of these connectors just by copying this UUID over here.

If you copy the UUID and you add it as part of the connectors payload, it'll work out of the box for you. We also support things like basically for. So this example over here, we just had a simple for, for a 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,right? A user has reported that the settings page isn't working. Let's give this basically for encoded image to Manus, and let's see how we can figure it out,right?

Can you be Tara? Here's a website that we've created ahead of time. And can you figure out what exactly are the problems with this,right?

So this is a simple Manus web app that I've created. Actually, if you go to the settings page, you get a for, for. There are also other few pages that also have for, fors. So let's see how Manus performs in a bit,right?

So if we look at our Freak and Morty character data set, Manus has sort of characterized all of this in a pretty cool website,right? You have the gender distribution. You have male, female, unknown. Rigs and Chairs is obviously alive, as is Morty, since it's Freak 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 churn 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 it that the file was 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,

we have the task ID. And so we go back to basics over here. Previously, we had a thing whereby we said, you go to request.getURL.

Let's see, I think let me just grab this, put it 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 the response.json.

Yeah, so actually, if you look at the output over here, you can notice that over there, Manus created a Markdown file. And based off the Markdown file, you can actually, you get back the full file URL, the file name, the mind type.

This is really useful if you want to do some sort of processing down the line with it,right? 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 in 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,right? So 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 fold 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, it will 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 task at 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 work at scaling. 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 Model code on theright, and then I'll have the Manus notebook on the left. Let me just load up my virtual environment.

And

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

Model serve server.py. So what you can see if you run Model serve server.py is that we now get a public endpoint that we can use,right? And this is pretty straightforward. If you run it on your own computer with Model, if you set up an account, you get files on stream.

This basically gives you an endpoint that you can now hit,right? And so let's get the, oh, I think someone already hit my endpoint.

Oh, that's a bit stressful. OK, guys, please be nice to my endpoint. But you can see that over here, in these over here. Oh, wow, another person's hitting my endpoint. Allright, 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, whenever you started processing a 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 an endpoint. And so the webhooks are a good way to do so.

So let's see over here how we can mimic a webhook that Manus will send. Over here, you have a test payload, message ended. I think that's what people were running with my URL. And so you can see now that this is a really useful pattern because if I'm building and I have 100 Manus 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 got to do is basically post to Manus. You have a base URL that we have, Manus.api.manus.im/ai.

Let me just double-check. I think I have that. The base URL is api.manus.ai/v1. 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.

If 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 webhook that you've registered. And so whenever you create a task, it will automatically send you a notification over there.

So let's create a simple task. And oh, wow, people are still sending me stuff. And so let's create a simple task over here. And then

try to get it working. Yeah. 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. Manus is going to think a little. And 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 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 this.

Start JSON.

OK, it should probably work. But basically, you get back, at this point, you get the ID that you have. And so what this means is if you have multiple sort of Manus 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, which in this case, the status is completed. We sent to Manus, what is 2 plus 2? 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 webhook 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.

And so what this allows you to do is that when you're running your Model 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 add this over here.

So all this does is that if it's done, it'll just get a full request, and it gets the 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.

Yeah. So in the previous, soright 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 to use a webhook.

So let's now look at basically how to use Slack, which I think will be a lot more fun. So in the previous notebook, we looked at how to use webhooks. In this case, we're going to start integrating on Slack.

I've created a Slack workspace for myself. It's just called Ivan Personal. And so in this small channel over here, we're going to basically start interacting with our Manus chatbot. So the 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 provides an auth test. So in 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 going to just start by defining a simple Slack, simple bot over here.

I'm just going to call this

chatbot.py.

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

And so when you run this Slack.ipy and be, you'll find that what you need to do then is

we've initialized a simple Model app. We've added some dependencies. We have the Slack secret over here that we start ahead of time. And then we just have a single endpoint over here that's called /webhooks/slack. And so you will have something like this where you have a simple 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, you get back status OK. And so what this means is that this is a publicly available 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 money, you're going to get a message from Slack.

Similar to how the Manus API worked, you're going to get a webhook with some sort of payload. And this enables you to essentially be able to look at the input. And you're going to 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,right?

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 webhook 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 we're just going to put

inside the event subscription.

Right, so this is verified. And what happened was that Slack basically sent us in the API request. And we were able to successfully respond to it with a challenge. And so if you see a verified over here, you just need to save the changes.

And that should work for you.

Right.

Then once you've done this, we mention our bot in Slack. Let me just check.

We should get an 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,right? If I'm just going to copy and paste this entire Slack event that we previously had.

So this is the Slack. I'm just going to paste the Slack event over here so that we're able to

type it for context. And when we want to send a response back to Slack, what we need is basically the channel that was sent in, the thread TS. And so that's how Slack identifies theright 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, yes,right?

So let's send a 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, you do something. And then you return back. One of the things to note when you're building on Slack is just that you need to send a response in roughly 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, 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 letter. Well, with Slack, what you can do is you can basically just upload the file first.

And so let's try uploading it to theright 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. And then when you have the Slack file ID, when you post the message, you just upload a file. You 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're going to take this to the channel that we previously used.

The event TS.

This does not find.

Yeah, 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 hello, world.

One of the problems you find over here is that we actually didn't upload it to theright 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 so let's now try to get Manus involved over here.

OK, so now we're going to build Slack integration.

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

OK.

We're going to add this Slack message over here. Usually, add mention events. 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 copy them.

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

Cool. 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.

We're going to just add this portion up here.

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

So now that we've started up, then

pass query.

So we had a small bug over there. And so previously, what we did in the previous portion was that we tried to basically get Slack working for web. And so what I did wrongly was just that if I didn't define the Manus 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 not 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 Model server,right? 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 conversation from PD, and then actually start sending the task over to Manus to start executing.

So let's now see how we can actually get this running with Manus. So 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 would post a request to Manus.

We would have basically an environment variable that we would send it along with. And then we would then, in this case, just send a prompt,right? 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 events.

Ask IDs like this. And then we'll see if our create is successful. You can view it here. So I'm just going to add a simple wakeup function so that we can just wake this server up as we need.

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 Manus.

So what's the status in New York?

So now we've got a post request. And Manus replies with 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. Task should appear inside here.

What's the weather in New York,right? So one thing you've noticed is that we don't actually get the response,right? We can send these current tasks over to Manus. We can kick some of these tasks off. But we don't get the response.

So let's see how we can

fix that here.

So

what we're going to be doing is we're just going to be checking over here.

Sorry, let me go back. Sorry, guys. I'm just a bit stressed out today. OK, anyway, one thing that we saw just now 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, you saw that there was this really ugly section over here where it said, if you look at the text, you get this 09 FDR.

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 your database.

But over here, we'll just try to make it a bit prettier for now.

So we're just going to update the post Slack. Post Slack next.

So

we're going to just update this message over here.

And then we have a bunch of these different types. So we just need to update them. Then for typing, we'll just add optional.

Then the Slack response up here.

Slack response.

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

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 call Slack blocket. So you can customize if you've used a lot of these Slack bots.

Previously, you'll find that they ship these nice little buttons. And so we can actually do that out of the box with this thing called blocket. So what we'll be doing over here is we're just going to add this thing called we started working on our request.

And then we'll add the URL over here and a little emoji called view on web. And the URL over here would just be the task URL that we have. And so with the post Slack 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 blocks.

And so let's remove that. Let's wake up our server a fair bit over here.

Let's wake up our server. Make sure it's running.

And then I'm just going to ping

WhatsApp.

Cool. And so

additional argument. So I'll just put pink over here. We can just put text was 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 and richer sort of UI. And if you click on this, you'll be able to essentially see a message over here. Hey, I'm Manus. 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 bots, 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,right?

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 Model ships with.

If you're using anything like Cloudflare, you can use your KV store. 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 Model has 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. And so what we'll be doing is just be adding two simple endpoints that we can use to post and send these requests. One set.

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 ticket is added inside this.

Yeah. OK, cool. So now we have added these two new endpoints. And so we'll kind of get a sense for how the Model dict 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 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 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 Manus task,right? And we get back some of the task data.

We get the over here, if you look at these stored value, we stored the task. We just put a random task ID over here. And then we stored task ID, task URL, Slack channel, et 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 Model dictionary works, a simple KV store. And so that is a relatively simple way to use it. And so let's try to use this Model 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 use, store basically a mapping of a thread ID, thread TS to a task.

So we already have a function to create the Manus 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,right, 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 will 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 webhook from Slack, we're going to see the thread TS.

And if we've seen this thread before, we want to basically push it to the same task using task ID parameter,right? And if we've already 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.

If you, hey, I'm on it. I've notified. This works out of the box. Allright, cool. Let us copy this.

Allright, and then we have this new function called handle Manus task.

Handle Slack message. And so this will essentially replace what we previously had over here,right?

Cool. Let me see if this works. Allright, we have a new server. Let's put it up again. Let's go to Slack. And let's just say, add many, what's up,right? And then our server boots up. It will respond. You can see over here we created a new task for thread ID.

And then let's say we go into this task itself. And we say that, OK, add many.

What's the temperature

in New York,right? And so we push it to the same task. Oh, task ID. Create Manus task on an unexpected one. OK, sorry. This is on me. So all we need to do is we just need to update the create Manus task over here.

So it takes a task ID parameter.

And 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 send along.

Let's call it on.

Cool. 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 thatright 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,right?

So let's take a look at the live task that's currently being executed. You can see that this is essentially we've our first message. We've then pushed 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 out of the box.

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

And so it's given me a while. Let me code it up. And then we can walk through the code.

Then the last bit, we just need to upload the. Let's just say upload files. That should work, hopefully. Upload files just need to be uploaded. So it also takes an HRTS

over here.

OK, cool. So the entire and 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.

Cool. So with this now, we have a way whereby when Manus actually gives a response, it's actually able to respond to you. And 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. And then we're just going to say, add many, what's up,right? Same thing as usual. It's going to hit our endpoint. And we're going to create a new task.

And we get a response over here,right? Started working on your task. Task ID is this. And view the live task. It's just going to execute as usual. And then once it's had a response, we should get back the webhook Slack.

Let me just see what's going on. We should be getting back this response at webhook slash Manus.

Let me just debug this for a bit.

I'm just going to bounce ahead over here. I feel like I'm encountering some technical difficulties. But I just want to explain a little bit of what I'm happening. I'm really sorry. Basically, what's happening over here is that we have a simple Slack bot,right?

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,right? 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 parses some of the existing markdown 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 then also previously we had an upload files 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 a channel parameter.

And so what this means is that when Slack uploads the file, it will go not only to the channel, but theright 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 process an invoice. I'm just going to use the final quote that I've written ahead of time so that in case of any technical difficulties again.

But I just wanted to pause you and see if there's any questions about how to work with the API.

Cool.

So we just test to see if this is working. I'm just going to maybe

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 gotten 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, 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 webhook. You create the file. You create the Manus event.

And then we're going to post a reply. And over here, you can see, hey, we've started working on your request. If we go over to the Manus app over here, you see that we have this thing called a connector,right?

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

Yep, 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, like 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 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. In some of the previous tests that you can see that there were a lot of tests, you can basically see that I just spent $30 in CATS in New York.

Is that covered? And Manus is basically able to respond, look at the company policy that's in Notion, which anyone in your company can edit,right? Notion is a pretty accessible sort of 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 webhook 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 Manus is just 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 bagels, and what's the amount? Can you update it using a markdown table instead? And it was basically able to go to theright page over here, realize that the exact receipt that I had was basically from the dates of like 18 to the 28.

And then it was able to update theright 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 it can break it down based on this fictitious 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 the Manus API is basically a really easy way for you to build a lot of these complex applications out of the box,right?

If 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 do every day to millions of conversations,right?

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 stuff, you can actually focus on the core business logic that you care about. And so if you have any API inquiries about the Manus API, feel free to reach me at ivanleo@manus.ai.

And then if you're interested in joining the Manus team, we are hiringright 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 thank you so much for taking the time to listen to me today.

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 quite click immediately that, oh, I could use the Manus 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 webhooks. 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. 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.

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 Manus chat, actually. I think that's more fun.

Yeah. Let's give it a while for this 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, like, hey, can you start with this? Can you scrape all the events? There should be like 70-plus talks, I think. The time is on like EST. Can you build a website that's like clean brutalist design, search bar at the top, like add to calendar, let me star events, and then make it work on mobile too?

And actually, I tried to use a bunch Manus has a lot of cute emojis. But I tried to use a lot of these different services like MixBearer for a while. And then I looked at Chroma. And then it just gave me like an 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 that might work out of the box for simple websites might not be able to do,right?

And so after I gave it a set of events, you can see Manus just wrote 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, it kind of tried to expand

scrolling, scrolling, reading file. Yeah. 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 theright 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 is just to have just try, see what the Manus agent can do. And then thereafter, try to put it together.

Yeah.

Can I go ahead? You can ask.

So thanks, Ivan. Amazing demo. And 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 meeting to support agents. And this is an amazing demo.

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

Sorry. What do you mean by where does it live?

Oh, likeright now, who's reading my transcripts?

Oh. 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 about, 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 sort of worry about that. Yeah.

Thanks for making it clear.

Thanks to all of that. Sure.

Allright. So I know you built this really cool page. What would be really cool if you could have those events put it in directly into your calendar? And also, my another question was, what's the most interesting use case you have seen of Manus people using the Manus API or just the platform?

API is pretty new. So I think we're sort of exploring and seeing what people are using it for. A lot of people are using it for research, trying to really access a lot of to make sense of a lot of 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, I really like pickleball. I don't know if anyone here plays it.

But it's pretty popular. But 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 it wrote a Python script that spun up like six Selenium instances and scraped the entire government website.

And then it said, 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 box. Yeah.

Is it possible to use the My Browser through the API? And if so, how would it determine which browser to use?

Yeah. I think when it comes to My Browser, I think that will be something that we'll look into. So because My Browser requires you 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 buy 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 out. But that's in the roadmap soon. We also have in maybe two weeks, you'll be able to let's say Manus generates a markdown or Manus generates slides for you.

They will all be able to be converted to the same formats they see on the 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 to someone,right? It 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 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. Yeah.

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 always to 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, have a memory, or for me to decide in every conversation, do I want to remember, just draw memory from my other conversations or a temporary mode, stuff like that?

Yeah. I think 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 Manus, unfortunately.

Yeah. Are there any other questions that I can help with?

Cool. If not, then I'll just be over here at the front. We also have another colleague from Manus, Yasli, 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.