# Coding an Autonomous Wall Street Coworker: Custom Skills, Connectors, and Event Hooks

Philipp Schmid · AI Engineer NYC 2026 · October 14

[Watch recording](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22308s)

[06:11:48](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22308s) Hi everyone, my name is Philipp and I work at [unclear] and happy second Gemini 4 day.

[06:11:54](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22314s) So who of you already tried the new model?

[06:11:57](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22317s) Can you raise your hands?

[06:11:58](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22318s) Okay, that's not enough.

[06:12:00](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22320s) So you should definitely take your time later, try it.

[06:12:04](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22324s) It is really good.

[06:12:05](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22325s) We are going to use it and show it in our talk as well.

[06:12:08](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22328s) So we are going to look at how you can build and code your own autonomous Wall Street co-workers.

[06:12:13](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22333s) so hopefully we have many finance people or engineers working in finance here.

[06:12:18](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22338s) So quickly before we go into where we are coming from,

[06:12:22](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22342s) two years ago we basically had a chat box.

[06:12:24](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22344s) We asked some simple questions like what's the capital of France,

[06:12:28](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22348s) who won the last European championship.

[06:12:30](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22350s) Then we moved to assistance using tools on our own computer,

[06:12:34](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22354s) having the first coding agents writing code for us.

[06:12:37](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22357s) And now we are moving into this autonomous co-worker area

[06:12:41](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22361s) where we basically give or create a digital employee

[06:12:45](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22365s) where we give an agent its own computer,

[06:12:48](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22368s) give it a task,

[06:12:49](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22369s) and hopefully come back a few hours later with a good result.

[06:12:52](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22372s) So what does a co-worker normally need?

[06:12:55](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22375s) And I think that goes for AI and for us humans as well.

[06:12:59](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22379s) We need a brain to be able to do our work.

[06:13:02](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22382s) We need a computer where we can save artifacts we create,

[06:13:07](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22387s) where we can iterate.

[06:13:08](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22388s) We need some kind of a new playbook, right?

[06:13:10](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22390s) when you hire someone new they are new to your environment to your domain you might have specific

[06:13:16](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22396s) workflows so you need playbooks we need tools for them to be able to do that job they all need

[06:13:22](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22402s) credentials in one or the other way then there might be some specific house rules on what you

[06:13:28](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22408s) should do or what you should not do what you can do on your own or where you need to get some

[06:13:32](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22412s) approvals and then of course there are hopefully some schedules for working hours when you can come

[06:13:38](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22418s) in or when you have to work. And the same goes for our agents. And we are going to work

[06:13:44](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22424s) through all of those seven steps and how you can build your own digital co-worker with

[06:13:49](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22429s) Gemini in this talk. But before we go in, yesterday was the big day. We announced Gemini

[06:13:54](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22434s) for Argon and made it available to you. Biggest new features, we have now a 1 million unified

[06:14:01](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22441s) context window. This means Gemini can generate up to 1 million output tokens. And we see

[06:14:06](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22446s) strong improvements especially on math and reasoning tasks where the model now has more than 64k

[06:14:11](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22451s) token available to think to work through to reason through some proofs and for math for for

[06:14:18](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22458s) math and then very also very good is like we tested that model heavily so we know there are

[06:14:24](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22464s) always some thinking around hey gemini is just banks benchmarks but the model is really good

[06:14:31](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22471s) you should definitely give it a try.

[06:14:33](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22473s) We use it extensively at Google.

[06:14:35](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22475s) There are already many projects by Google employees

[06:14:38](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22478s) who have used it.

[06:14:39](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22479s) The easiest way to get started is the Interactions API.

[06:14:42](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22482s) It's literally four lines of code,

[06:14:44](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22484s) which for you to take, you get your API key in AI Studio,

[06:14:47](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22487s) aistudio.com slash API key,

[06:14:50](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22490s) and then you can immediately send your request.

[06:14:52](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22492s) It's also, I would say, quite affordable

[06:14:54](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22494s) for a frontier model with $2 in and $10 out.

[06:14:58](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22498s) You should definitely try if you have a free minute later

[06:15:01](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22501s) or even if you have some agents running right now,

[06:15:04](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22504s) give it a link, tell it, hey, please set up Gemini 4

[06:15:06](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22506s) and give it a try.

[06:15:08](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22508s) So what have Googlers done so far with the model?

[06:15:10](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22510s) I think it's very impressive because it's like a super new model.

[06:15:13](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22513s) We had it available internally to test for a few weeks already,

[06:15:16](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22516s) but Googlers are using it so heavily

[06:15:19](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22519s) and shipping so many cool things.

[06:15:20](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22520s) We had the Chrome team basically accelerating

[06:15:23](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22523s) some decoupling of the Chromium browser.

[06:15:26](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22526s) We have Gemma, which is our open model

[06:15:28](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22528s) where Gemini accelerated Gemma

[06:15:31](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22531s) to be more easily and more efficient to run.

[06:15:34](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22534s) The ADK team from cloud improved their framework

[06:15:37](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22537s) and then many, many other things,

[06:15:39](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22539s) and especially the right one at the bottom.

[06:15:41](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22541s) It's like we use it internally heavily

[06:15:44](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22544s) and we see strong improvements

[06:15:45](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22545s) for our internal code base as well.

[06:15:48](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22548s) So what have people built?

[06:15:50](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22550s) There are some demos.

[06:15:52](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22552s) You can look them up,

[06:15:53](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22553s) but there's one specific one from a colleague of mine

[06:15:55](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22555s) which I want to show.

[06:15:56](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22556s) he basically prompted Gemini to build a custom 3D ray tracer in Python.

[06:16:03](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22563s) And it was completely built from Gemini and nothing external tools and at the end just Python.

[06:16:09](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22569s) And it also used a Gemini TTS model and Luria to add some voiceover to explain how it works.

[06:16:15](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22575s) And it's like very impressive for me how far we can push those models now.

[06:16:19](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22579s) So try to be very ambitious.

[06:16:21](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22581s) So how can we build our agent?

[06:16:24](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22584s) And in Gemini API, we have a product called Managed Agents.

[06:16:28](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22588s) And Managed Agents is basically a simple way for you to build a remote agent

[06:16:33](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22593s) where you give Gemini a sandbox which it can use to run tools.

[06:16:39](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22599s) So when we normally build an agent, we have this weird tool calling group, right?

[06:16:44](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22604s) We send a request to the model.

[06:16:45](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22605s) The model might generate a JSON function call.

[06:16:48](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22608s) We receive that function call.

[06:16:50](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22610s) We run that function call on our machine, execute the code,

[06:16:53](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22613s) and then we go back to the model.

[06:16:55](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22615s) And with managed agents, we basically provide a sandbox

[06:16:57](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22617s) which Gemini can directly use to run all of those calls.

[06:17:01](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22621s) So if it decides to execute code to write a file,

[06:17:04](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22624s) it has its own computer available for it to use,

[06:17:07](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22627s) and it takes just an API call.

[06:17:09](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22629s) So instead of providing the model ID with Gemini 4 Argon,

[06:17:13](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22633s) you provide the agent ID.

[06:17:15](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22635s) In this case, it's anti-gravity preview 09.

[06:17:18](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22638s) Give it a prompt.

[06:17:19](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22639s) The environment is remote,

[06:17:21](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22641s) so you want to run it in the managed sandbox.

[06:17:23](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22643s) and that's all it takes.

[06:17:25](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22645s) So let's get into building Buck.

[06:17:28](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22648s) Buck is our co-worker for today, and Buck needs a brain.

[06:17:31](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22651s) Our brain is going to be Gemini,

[06:17:34](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22654s) our computer is going to be Agents,

[06:17:36](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22656s) and then we all love all of the other things.

[06:17:38](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22658s) So how can you create an agent?

[06:17:40](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22660s) In Managed Agents, you have a very simple API

[06:17:43](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22663s) where you can define your own agent.

[06:17:45](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22665s) So you give it an ID.

[06:17:46](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22666s) That's the name which you are going to use later

[06:17:48](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22668s) to call the agent.

[06:17:49](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22669s) We have the base agent, so that's the main agent underlying.

[06:17:53](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22673s) In this case, it's the agent harness.

[06:17:55](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22675s) So the remote agent uses the same agent harness,

[06:18:00](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22680s) which we have in Antigravity as well.

[06:18:02](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22682s) So if you are using Antigravity as your coding agent,

[06:18:05](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22685s) you get the same agent harness remotely.

[06:18:08](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22688s) Then we want to use the new model.

[06:18:10](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22690s) So we define our model.

[06:18:11](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22691s) We have a system instruction, you are back.

[06:18:14](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22694s) And then all it takes to call it, again, interactions API, create.

[06:18:19](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22699s) And instead of using the model ID for Gemini

[06:18:22](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22702s) or the default agent, we use our own agent buck.

[06:18:26](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22706s) And our agent needs a computer,

[06:18:28](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22708s) and the computer normally needs some additional files,

[06:18:31](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22711s) additional scaffolding.

[06:18:33](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22713s) So with managed agents, you can provide your skills

[06:18:36](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22716s) or an agents MD file, maybe from your GitHub repository.

[06:18:38](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22718s) You can inline those files directly.

[06:18:41](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22721s) You can provide a GitHub repository,

[06:18:43](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22723s) private or public, with your skills,

[06:18:45](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22725s) and you can connect GCS buckets.

[06:18:48](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22728s) So you can already bootstrap the environment

[06:18:50](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22730s) the agent is going to work in.

[06:18:51](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22731s) and everything in managed agent lives as a file.

[06:18:55](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22735s) So we have skills, we have hooks, we have system instructions.

[06:18:59](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22739s) At the end, it's just a file system or the agent's own computer

[06:19:03](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22743s) where it can create new skills if it thinks it needs to improve itself,

[06:19:07](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22747s) where it can store memories from previous sessions or learning.

[06:19:11](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22751s) So at the end, we just work with files.

[06:19:13](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22753s) And for knowledge or for our agent,

[06:19:17](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22757s) I like to separate those in three different categories.

[06:19:20](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22760s) So we have knowledge which we always need to include into every request.

[06:19:26](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22766s) That's normally the system instructions.

[06:19:27](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22767s) We want to be very concise.

[06:19:29](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22769s) We want to try to keep it very short because that's something we need to pay on every request.

[06:19:34](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22774s) So if we have very long system instructions, all of our requests are going to be much more expensive.

[06:19:39](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22779s) If we have concise, then we have knowledge which the agent can decide when it needs to use them or not.

[06:19:47](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22787s) So that's typically with skills, right?

[06:19:49](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22789s) with skills we have very short descriptions which give the agent some guidance on like hey you can

[06:19:55](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22795s) use that skill if the user wants to do a certain task or if you have to do certain tasks and then

[06:19:59](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22799s) can

[06:20:00](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22800s) the agent can read that skill.

[06:20:02](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22802s) But for skills, we also want to make sure that we are not having super long, dense skills because that's also a high cost at the end.

[06:20:10](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22810s) Context is very valuable for us, so we want to decouple them and separate them into much more slices where we can then have dedicated references and scripts

[06:20:20](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22820s) if we want the agent to do very certain things

[06:20:24](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22824s) where it needs more context.

[06:20:26](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22826s) Okay, so let's look at an example skill

[06:20:28](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22828s) which we are going to use.

[06:20:29](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22829s) So we have a portfolio audit.

[06:20:30](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22830s) The agent should use it.

[06:20:32](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22832s) It has some instructions available for it,

[06:20:34](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22834s) how to run it.

[06:20:34](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22834s) So we have a Python script.

[06:20:36](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22836s) The agent can run,

[06:20:37](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22837s) and then some additional information

[06:20:38](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22838s) on what it needs to do with the results

[06:20:40](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22840s) and where to store it.

[06:20:43](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22843s) Our fourth part of our onboarding

[06:20:46](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22846s) for our coworkers tools, right?

[06:20:48](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22848s) We humans use normal software for agents that's either built-in skills like Google Search, code executions, or MCP server.

[06:20:55](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22855s) Or if you don't have an MCP server and rather want to write a local function, that's also possible.

[06:21:01](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22861s) So, managed agents, we still have our agents create.

[06:21:04](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22864s) We are now extending it to define our tools.

[06:21:08](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22868s) We have built-in tools from the Gemini API for Google Search.

[06:21:12](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22872s) So, there's nothing you need to additionally do to get Google Search integrated.

[06:21:15](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22875s) but if you want to use, for example, spreadsheets,

[06:21:19](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22879s) Workspace has now an MCP server available for Gmail for spreadsheets,

[06:21:23](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22883s) so we can use that.

[06:21:25](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22885s) Or if you want to provide your own functions or MCP server,

[06:21:29](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22889s) that's also possible.

[06:21:30](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22890s) So for your own function, it still works the same way

[06:21:33](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22893s) as you normally do with models.

[06:21:35](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22895s) So the agent creates a function call,

[06:21:36](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22896s) and then you send back the function result.

[06:21:39](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22899s) So it's basically for you a way to have agentic capabilities

[06:21:43](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22903s) outside of these agents' environment and computers.

[06:21:46](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22906s) So if you want to do certain things

[06:21:48](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22908s) where the agent should not run the execution in the sandbox,

[06:21:51](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22911s) that's a way for you to do it.

[06:21:53](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22913s) And then we are logins.

[06:21:55](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22915s) And I think that's, for me, the most exciting

[06:21:57](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22917s) and the greatest feature about the Managed Agents API

[06:22:00](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22920s) because credentials are super hard

[06:22:02](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22922s) and super easy to get wrong with agents.

[06:22:04](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22924s) And I think the previous talk already also mentioned

[06:22:07](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22927s) that we are very careful about using agent

[06:22:10](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22930s) because things can go wrong very easily.

[06:22:12](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22932s) And we've thought a lot about this with managed agents,

[06:22:15](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22935s) and we have support for three different ways of credentials,

[06:22:17](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22937s) which makes it secure for your agent to use them

[06:22:20](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22940s) and provide an isolated way.

[06:22:22](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22942s) So we have bearer tokens for normal API calls,

[06:22:26](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22946s) very familiar if you are doing software engineering.

[06:22:28](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22948s) We have OAuth for all of the consumer-oriented MCP servers,

[06:22:32](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22952s) all like tools.

[06:22:33](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22953s) And then, of course, we need environment variables

[06:22:35](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22955s) if we want to use certain CLIs or other features.

[06:22:38](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22958s) and for managed agents we are separating them via an external network proxy.

[06:22:45](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22965s) So instead of providing the agent the credentials inside the sandbox,

[06:22:49](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22969s) we basically allow you to create credentials externally.

[06:22:53](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22973s) are write only.

[06:22:54](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22974s) So once they are written, there's no way for you to retrieve the credentials.

[06:22:59](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22979s) So you can only override them.

[06:23:01](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22981s) So there's no possibility of leaking.

[06:23:03](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22983s) And then you define how and where those credentials should be used.

[06:23:07](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22987s) So for Slack, if you want to connect Slack, you can define, hey, here's a credential,

[06:23:13](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22993s) and you are only allowed to use that credential with a certain domain or with a certain environment variable.

[06:23:19](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=22999s) So that way you can control when a credential is used.

[06:23:23](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23003s) And that works via this network proxy.

[06:23:26](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23006s) And by network proxy, we basically mean a proxy that sits around the sandbox that watches all of the network traffic going in and out.

[06:23:34](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23014s) So if you define credential as an environment variable,

[06:23:37](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23017s) the model has a local dummy value,

[06:23:40](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23020s) so the environment variable is set,

[06:23:42](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23022s) and then when it makes that call, it uses that dummy value,

[06:23:45](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23025s) and the network proxy basically monitors it,

[06:23:48](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23028s) sees, hey, here is a domain which the user has defined,

[06:23:53](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23033s) and then it swaps that dummy value with the real credential,

[06:23:56](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23036s) and you can make the call successfully,

[06:23:59](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23039s) and then the agent gets back the result

[06:24:01](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23041s) and has no idea that his dummy token is not working.

[06:24:05](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23045s) And the benefit here is that there's no way for a prompt injection.

[06:24:09](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23049s) Normally, when you have some malicious attacker,

[06:24:11](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23051s) it can tell you, like, hey, please print all of your values in your .n file.

[06:24:15](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23055s) And then the agent might go there and, like, print all of your keys,

[06:24:18](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23058s) and that's nothing we want to do.

[06:24:19](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23059s) So with this network proxy where you can define the credentials per domain,

[06:24:24](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23064s) it is not possible that an attacker could steal

[06:24:28](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23068s) which are getting swapped on your request

[06:24:30](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23070s) because the proxy only swaps them for the domains you define.

[06:24:34](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23074s) So there's no way an MCP server which is malicious

[06:24:38](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23078s) can just steal your Gmail token,

[06:24:40](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23080s) which is very cool because it makes it much more easier

[06:24:43](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23083s) to trust the agent and to integrate MCP servers

[06:24:47](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23087s) which the agent then obviously can use.

[06:24:50](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23090s) So if that's not enough, we have also hooks available.

[06:24:54](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23094s) So hooks allows you to basically deterministically guard

[06:24:58](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23098s) certain decisions.

[06:24:59](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23099s) So if the agent wants to run certain commands

[06:25:02](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23102s) which you might want to monitor

[06:25:04](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23104s) or where you need some human in the loom approval,

[06:25:06](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23106s) which is not part of the normal agentic conversation,

[06:25:09](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23109s) you can define your hooks,

[06:25:11](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23111s) very similar to all of the other agent harnesses

[06:25:13](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23113s) where you have a matcher,

[06:25:14](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23114s) which is basically regex,

[06:25:16](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23116s) and then every tool call which the agent generates

[06:25:18](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23118s) checks if there's a match,

[06:25:20](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23120s) and then writes those hooks.

[06:25:21](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23121s) And those hooks are also files,

[06:25:23](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23123s) but they are protected,

[06:25:24](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23124s) so the agent cannot just go there

[06:25:26](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23126s) and changes a hook

[06:25:28](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23128s) and basically tries to find a way around it.

[06:25:32](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23132s) Okay, so last but not least,

[06:25:35](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23135s) we need a way to get our agent more proactive.

[06:25:39](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23139s) And currently we support one kind of triggers,

[06:25:42](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23142s) basic cron triggers, which you can set up,

[06:25:44](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23144s) schedule every 30 days a month at a.m.

[06:25:49](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23149s) You want the agent to run a certain trigger

[06:25:51](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23151s) with a certain input in the same environment

[06:25:54](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23154s) to do maybe some due diligence, some auditing.

[06:25:56](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23156s) and we are also working on webhooks

[06:25:59](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23159s) that you can even make this much more interactive

[06:26:01](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23161s) that you could connect external webhooks

[06:26:04](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23164s) like from some certain SAC provider

[06:26:06](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23166s) or maybe other providers you work together with

[06:26:09](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23169s) which would directly then call your agent.

[06:26:11](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23171s) The agent does some first auditing

[06:26:13](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23173s) and then basically can call your Slack

[06:26:15](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23175s) or your Microsoft Teams directly

[06:26:17](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23177s) without you even needing to manage

[06:26:19](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23179s) some infrastructure at all.

[06:26:23](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23183s) So that's that.

[06:26:25](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23185s) final picture and now let's look

[06:26:27](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23187s) at some real demos

[06:26:29](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23189s) and let's hopefully hope that

[06:26:31](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23191s) the wifi is good enough.

[06:26:34](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23194s) So I told Gemini

[06:26:36](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23196s) that I want to do a cool Google Sheets demo

[06:26:38](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23198s) and it helped me create basically this whole

[06:26:40](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23200s) Google Sheets replication in

[06:26:41](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23201s) my browser and

[06:26:43](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23203s) when I click here we basically

[06:26:46](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23206s) simulate this cron trigger so we send

[06:26:48](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23208s) a real API call to managed

[06:26:50](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23210s) agents. It should use our

[06:26:52](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23212s) portfolio auditing skill

[06:26:53](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23213s) and it runs the request.

[06:26:55](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23215s) So first step basically is like,

[06:26:57](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23217s) hey, I need to read the skill.

[06:27:00](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23220s) It gets the result back.

[06:27:02](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23222s) So it tries to understand what it should do here.

[06:27:04](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23224s) It's like, I hope that's roughly accurate

[06:27:06](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23226s) on like the Google Sheets.

[06:27:08](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23228s) But it basically runs through all of those calls,

[06:27:11](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23231s) calls financial services,

[06:27:13](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23233s) tries to see, okay,

[06:27:14](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23234s) did the market or the stock price change?

[06:27:16](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23236s) And then at the end,

[06:27:17](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23237s) hopefully it should update our own Google Sheets

[06:27:20](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23240s) completely automatically.

[06:27:22](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23242s) so it's still working through it, it has some first result

[06:27:27](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23247s) and it updates the Google Sheet based on the trigger

[06:27:30](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23250s) and that trigger would run every 8.30am without you needing to do

[06:27:34](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23254s) anything and then of course if the agent has access to Slack

[06:27:38](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23258s) then it can even post in some specific trading channel

[06:27:42](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23262s) okay what changed, what is going on, how does it work and

[06:27:46](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23266s) here we have an example where I can just

[06:27:50](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23270s) ask Buck

[06:27:52](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23272s) any

[06:27:54](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23274s) recommendation

[06:27:58](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23278s) and hopefully this works as well

[06:28:00](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23280s) so it takes a little bit of time, you have seen in the

[06:28:01](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23281s) other demo, we have seen all of that

[06:28:03](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23283s) perfect, so there are

[06:28:05](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23285s) three positions, so that's based on like this

[06:28:08](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23288s) thread content

[06:28:09](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23289s) so it has all of the previous turns available

[06:28:12](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23292s) and it provides the context of

[06:28:13](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23293s) what changed, but it's still basically

[06:28:15](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23295s) not taking actions based on

[06:28:17](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23297s) the system instructions you gave and all of

[06:28:19](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23299s) the infrastructure you need to run that agent is

[06:28:23](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23303s) part of the managed agents environment. So it's very easy for you to get started, to

[06:28:27](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23307s) integrate those into the tools you already use, provide

[06:28:31](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23311s) the systems you need, and then to get started.

[06:28:39](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23319s) Back to the slide. So the whole

[06:28:41](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23321s) co-worker, which we need in one service, we have the brain, Gemini.

[06:28:45](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23325s) We have the computer with managed agents.

[06:28:47](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23327s) We can provide skills for the same agents you use,

[06:28:51](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23331s) maybe on your local computer.

[06:28:53](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23333s) You can use the tools.

[06:28:54](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23334s) You can provide MCP server for external services,

[06:28:57](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23337s) data providers to connect.

[06:28:58](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23338s) We have a secure way for you to provide credentials

[06:29:01](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23341s) to rotate credentials.

[06:29:03](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23343s) We have hooks to protect certain deterministic logic.

[06:29:06](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23346s) And of course, we have triggers

[06:29:07](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23347s) to much more proactively integrate it into it.

[06:29:10](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23350s) So thanks for listening,

[06:29:12](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23352s) and hopefully go hire your first AI co-worker.

[06:29:15](https://www.youtube.com/watch?v=jiUC6IUMdvc&t=23355s) Thank you.