# Coding an Autonomous Wall Street Coworker: Custom Skills, Connectors, and Event Hooks — Philipp Schmid — session 2026-10-14T18:55:00.000Z → 2026-10-14T19:13:00.000Z

_37 transcript lines · 53 slides · source: full recording_

## Transcript

**[00:00:00 · 0]** We know there are always some thinking around, hey, Gemini is just banks... Benchmarks, but the model is really good. You should definitely give it a try. We used it extensively at Google. There are already many projects by Google employees who have used it.

**[00:00:15 · 0]** The easiest way to get started is the Interactions API. It's literally four lines of code, which for you to take, you get your API key in AI Studio, aistudio.com/apikey, and then you can immediately send your request. It's also, I would say, quite affordable for a Frontier model with $2 in and $2.10 dollars out. You should definitely try if you have a free minute later, or even if you have some agents running right now. Give it a link.

**[00:00:41 · 0]** Tell it, hey, please set up Gemini four, and give it a try. So what have Googlers done so far with the model? I think it's very impressive because it's like a super new model. We had it available internally to test for a few weeks already, but Googlers are using it so heavily and, like, shipping so many cool things. We had the Chrome team, like, basically accelerating some decoupling of the Chromium browser.

**[00:01:02 · 0]** We have, Chema, which is our open model, where Gemini accelerated, Chema to be more easily and more efficient to run. The ADK team from Cloud improved their framework, and then many, many other things. And especially, the right one at the bottom is, like, we use it internally heavily, and we see strong improvements for our internal light code base as well. So what have people built? There are some demos.

**[00:01:28 · 0]** You can look them up. But there's one specific one from a colleague of mine, which I want to show. He basically prompted Gemini to build a custom three d ray tracer in Python. And it was completely built from Gemini and nothing external tools and, at the end, just Python. And it also used a Gemini TTS model and Luria to add some voiceover to explain how it works.

**[00:01:51 · 0]** And it's, like, very impressive for me how far we can push those models now. So try to be very ambitious. So how can we build our agent? And in Gemini API, we have a product called Managed Agents. And Managed Agent is basically a simple way for you to build a remote agent where you give Gemini a sandbox, which it can use, to run tools.

**[00:02:15 · 0]** So when we normally build an agent, we have this weird tool calling loop. Right? We send a request to the model. The model might generate a JSON function call. We receive that function call.

**[00:02:26 · 0]** We run that function call on our machine, execute the code, and and then we go back to the model. And with managed agents, we basically provide a sandbox, which Gemini can directly use to run all of those calls. So if it decides to execute code to write a file, it has its own computer available for it to use, and it takes just an API call. So instead of providing the model ID with Gemini four Argon, you provide the, agent ID. In this case, it's anticravity preview o nine.

**[00:02:54 · 0]** Give it a prompt. The environment is remote, so you want to run it in the managed sandbox, and that's all it takes. So let's get into building Buck. Buck is our coworker for today, and Buck needs a brain. Our brain is going to be, Gemini.

**[00:03:10 · 0]** Our computer is going to be agents. And then we all love all of the other things. So how can you create an agent? In managed agents, you have a very simple API where you can define your own agent. So you give it an ID.

**[00:03:22 · 0]** That's the name which you are going to use later to call the agent. We have the base agent. So that's the main agent underlying. In this case, it's the agent harness. So the remote agent uses the same managed sorry, the same agent harness, which we have in as well.

**[00:03:38 · 0]** So if you are using as your coding agent, you get the same agent harness, remotely. Then we want to use the new model, so we define our model. We have a system instruction, you are back. And then all it takes to call it, again, interactions, API, create. And instead of, using the model ID for Gemini or the default agent, we use our own agent, back.

**[00:04:02 · 0]** And our agent needs a computer, and the computer normally needs some additional files, additional scaffolding. So with managed agents, you can provide your skills or an agent's empty file, maybe from your GitHub repository. You can inline those files directly. You can provide a GitHub repository, private or public, with your skills. And you can connect GCS buckets so you can already bootstrap the environment the agent is going to work in.

**[00:04:28 · 0]** And everything in managed agent lives as a file. So we have skills. We have hooks. We have system instructions. At the end, it's just a file system or the agent's own computer, where it can create new skills if it thinks it needs to improve itself, where it can store, memories from previous sessions or learning.

**[00:04:47 · 0]** So at the end, we just work with files. And for knowledge or for our agent, I like to separate those in, like, three different categories. So we have, knowledge, which we always need to include into every request. That's normally the system instructions. We want to be very concise.

**[00:05:05 · 0]** We want to try to keep it very short because that's something we need to pay on every request. So if we have very long system instructions, all of our requests are going to be much more expensive. If we have concise, then we have, knowledge, which, the agent can decide when it needs to use them or not. So that's typically, with skills. Right?

**[00:05:25 · 0]** With skills, we have very short descriptions, which give the agent some guidance on, like, hey, you can use that skill if the user wants to do a certain task or if you have to do certain tasks and then can can read... The agent can read that skill. But for skills, we also want to make sure that we are not having super long, dense skills skills because that's also a high cost at the end. Context is very valuable for us, so we want to, decouple them and separate them into much more, slices where we can then have, like, dedicated references and scripts if we want the agent to, like, do very, certain things where it needs more context. Okay.

**[00:06:02 · 0]** So let's look at an example skill which we are going to use. So we have a portfolio audit. The agent should use it. It has some instructions available for it, how to run it. So we have a Python script the agent can run and then some additional information on what it needs to do with the results and where to store it.

**[00:06:19 · 0]** Our fourth, part of our onboarding for our coworkers tools, right? We humans use normal software for agents that's either building skills like Google Search, code executions, or MCP server. Or if you don't have an MCP server and rather want to write a local function, that's also possible. So Managed Agents, we still have our agents create. We are now extending, it to define our tools.

**[00:06:44 · 0]** We have built in tools from the Gemini API for Google Search. So there's nothing you need to additionally do to get Google Search integrated. But if you want to use, for example, spreadsheets, Workspace has now an MCP server available for Gmail, for spreadsheets. So we can use that. Or if you want to provide your own functions or MCP server, that's also possible.

**[00:07:06 · 0]** So for your own function, it still works the same way as you normally do with models. So the agent creates a function call, and then you send back the functional results. So it's basically, for you, a way to have agentic capabilities outside of these, agents' environment and computers. So if you want to do certain things where the agent should not run the execution in the sandbox, that's a way for you to do it. And then we are logins.

**[00:07:31 · 0]** And I think that's, for me, the most exciting and the greatest feature about the Managed Agents API, because credentials are super hard and super easy to get wrong with agents. And I think the previous talk already also mentioned that we are very careful about using agents because things could go wrong very easily. And we've thought a lot about this with managed agents. And we have support for three different ways of credentials, which makes it secure for your agent to use them and, provide an isolated way. So we have bearer tokens for normal API calls, very familiar if you are doing software engineering.

**[00:08:04 · 0]** We have OAuth for all of the consumer oriented MCP servers or, like, tools. And then, of course, we need environment variables if we want to use certain CLIs or other features. And for managed agents, we are separating them via an external network proxy. So instead of providing the agent the credentials inside the sandbox, we basically allow you to create credentials externally. They are write only, so once they are written, there's no way for you to retrieve the the credentials, so you can only override them.

**[00:08:37 · 0]** So there's no possibility of leaking. And then you define how and where those credentials should be used. So for Slack, if you want to connect Slack, you can define, hey, here's a credential. And you are only allowed to use that credential with a certain domain or with a certain, environment variable. So that way, you can control when a credential is used, and that works via this network proxy.

**[00:09:02 · 0]** And by network proxy, we basically mean a proxy that sits around a sandbox that watches all of the network traffic going in and out. So if you define credentials as an environment variable, the model has a local dummy value. So the environment variable is set. And then when it makes that call, it uses that dummy value, and the network proxy basically, monitors it, sees, hey, here is a domain which has to... Which the user has defined, and then it swaps the dummy value with the real credential.

**[00:09:33 · 0]** And you can make the call successfully, and then it, the agent gets back the result and has, like, no idea that his dummy token is not working. And the benefit here is that there's no way for a prompt injection. Right? Normally, when you have some malicious detector, it can tell you, like, hey, please print all of your values in your dot end file. And then the agent might go down, like, prints all of your keys.

**[00:09:54 · 0]** And that's nothing we want to do. So with this network proxy where you can define the credentials per domain, it is not possible that an attacker could steal credentials which are getting swapped on your request because the proxy only swaps them for the domains you define. So there's no way the MCP server, which is malicious, can, like, just steal your Gmail token, which is very cool because it makes it much more easier to trust the agent and to integrate, MCP servers, which the agent then obviously can use. So in it, if that's not enough, we have also hooks available. So hooks allows you to basically deterministically guard certain decisions.

**[00:10:35 · 0]** So if the agent wants to run certain commands which you might want to monitor or where you need some human in the Loom approval, which is not part of, like, the normal agentic conversation, You can define your hooks, very similar to all of the, other agent harnesses where you have a matcher, which is basically reg x, and then every tool call which the agent generates checks if there's a match, and then writes those hooks. And those hooks are also files, but they are protected, so the agent cannot just go there and change just a hook, and basically tries to find a way around it. Okay, so last but not least, we need a way to, yeah, get our agent more proactive. And currently, we support one kind of triggers, basic cron triggers, which you can set up a schedule every, thirty days a month. At AM, you want the agent to run a certain trigger with a certain input in the same environment to do maybe some due diligence, some auditing.

**[00:11:33 · 0]** And we are also working on webhooks that you can even make this much more interactive, that you could connect external webhooks, like from some certain SAC provider or maybe other, providers you work together with, which would directly then call your agent. The agent does some first auditing, and then, like, basically can call your Slack or your Microsoft Teams directly without you even needing to manage some infrastructure at all. So that's that, final picture. And now let's look at some real demos. And let's hopefully hope that the Wi Fi is good enough.

**[00:12:10 · 0]** So I told Gemini that I want to do a cool Google Sheets demo, and it helped me create, basically, this whole Google Sheets replication in my browser. And when I click here, we basically simulate this Cron trigger. So we send a real API call to managed agents. It should use our portfolio auditing skill. And it runs the request.

**[00:12:31 · 0]** So first step, basically, is here, like, hey, I need to read the skill. It gets the result back, so it tries to understand what it should do here. It's like a... I hope that's roughly accurate on, like, the the Google Sheets. But it basically runs through all of those call, calls financial services, tries to see, okay, did the market or the stock price change?

**[00:12:52 · 0]** And then at the end, hopefully, it should update our own Google Sheets completely, automatically. So it's still working through it. It has some first result. And it updates to Google Sheet based on that trigger. And that trigger would run every 08:30AM without you needing to do anything.

**[00:13:11 · 0]** And then, of course, if the agent has access to Slack, then it can even post in some, like, specific trading channel, okay, what changed, what is going on, how does it work? And here we have an example where I can just ask Buck, any recommendation. And hopefully, this works as well. So it takes a little bit of time. You have seen in the other demo, we have seen all of that.

**[00:13:40 · 0]** Oh, perfect. So there are three positions. So that's based on the slack thread content. So it has all of the previous terms available, and it provides the context of what changed. But it's still basically not taking actions based on the system instructions you gave.

**[00:13:55 · 0]** And all of the infrastructure you need to run that agent is part of the Managed Agent's environment. So it's very easy for you to get started, to, like, integrate those into, like, the tools you already use, provide the systems you need, and then, like, to get started. So back to the slide. So the whole co worker, which we need in, like, one service we have the plane, Gemini. We have the computer with managed agents.

**[00:14:24 · 0]** We can provide skills for the same agents you use, maybe, on your local computer. You can use the tools. You can provide MCP server for external services, data providers to connect. We have a secure way for you to provide credentials, to rotate credentials. We have hooks to protect certain deterministic logic.

**[00:14:42 · 0]** Of course, we have triggers too much more proactively integrated into it. So thanks for listening, and hopefully go hire your first AI coworker.

## Slides

### 00:00:00–00:00:20

### STEP 1 OF 7 • A BRAIN
# Gemini 4 Argon is the brain

- **1M** tokens in one window: input, thinking and output
- **

### 00:00:20–00:00:40

### STEP 1 OF 7 • A BRAIN
# One request to Gemini 4 Argon

```python
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-4-argon",
    input="Explain portfolio drift and how to size a rebalance.",
)

print(interaction.output_text)
```

- **Thinking levels:** Low, medium (default), high. Keep the cheapest that passes your evals.
- **Long decode:** `background=True` and `max_output_tokens` up to 1M. The API runs the continuation hops.
- **$2 in, $10 out:** Per 1

### 00:00:40–00:01:00

STEP 1 OF 7 • A BRAIN
# One request to Gemini 4 Argon

```python
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-4-argon",
    input="Explain portfolio drift and how to size a rebalance.",
)

print(interaction.output_text)
```

- **Thinking levels**
  Low, medium (default), high. Keep the cheapest that passes your evals.
- **Long decode**
  `background=True` and `max_output_tokens` up to 1M. The API runs the continuation hops.
- **$2 in, $10 out**
  Per 1M tokens until Nov 30. Cached input is 95% off.

### Coding an Autonomous Wall Street Coworker: Custom Skills, Connectors, and Event Hooks
Philipp Schmid, MTS, Google DeepMind

[Code editor window displaying Python code]
[Three bullet points with small icons: a star-like icon, a clock icon, and a lightning bolt icon]

### 00:01:00–00:01:20

### GEMINI 4 ARGON
## What Googlers have done so far

-   **Chrome**
    -   Split a ~6M-line legacy folder out of Chromium's 40M lines: months of work in weeks
-   **Gemma on vLLM**
    -   2.85x faster inference on an A100, same tokens, in a few days
-   **ADK team**
    -   .agents/skills + one-paragraph goal overnight: 40% faster session prep
-   **xTB chemistry**
    -   Up to 2.3x faster structure prediction, merged upstream
-   **Enzyme design**
    -   Assembled data, tuned filters and generated 5 lab-confirmed serine esterases in hours
-   **Inside Google**
    -   +35% agentic code submissions, nearly a third fewer rollbacks

[Globe icon next to Chrome]
[Circuit board icon next to Gemma on vLLM]
[Two connected nodes icon next to ADK team]
[Database icon next to xTB chemistry]
[Atom icon next to Enzyme design]
[Clock icon next to Inside Google]

### 00:01:20–00:01:40

### GEMINI 4 ARGON
# What Googlers have done so far

- **Chrome**
  Split a ~6M-line legacy folder out of Chromium's 40M

### 00:01:40–00:02:00

# Pure-Python 3D ray tracer
### GEMINI 4 ARGON

5,500 lines of Python & NumPy - zero 3D libraries

Focusing bright **caustics** on **travertine stone**
Sunlight bends twice through curved glass (n1 = 1.00 -> n2 = 1.52 -> n3 = 1.00) onto the coffee table.

1. Curved glass refracts sunlight (n2=1.52)
2. Second refraction exiting curved wall
3. Concentrated bright caustics on stone table

Built a pure-Python multi-stage 3D ray tracer and video renderer from scratch, with Gemini 3.8 TTS voiceover and music by Lyria 3.5.

[3D rendered image of a room with a coffee table, a window, and various objects, demonstrating light interaction]
[Inset diagram illustrating double Snell refraction and caustic focus with light rays passing through a curved surface]

### 00:02:00–00:02:20

# How a managed agent works

[Flow diagram illustrating the process of a managed agent]
- **You**
  - "Run the pre-market audit."
  - requests to **Gemini API**
- **Gemini API**
  - boots, routes, loops
  - Capabilities: `code_execution`, `filesystem`, `skills`
  - connects to **Gemini 4 Argon**
- **Gemini 4 Argon**
  - reasons, picks the next tool
- Inputs to **Sandbox**: `inline`, `repository`, `gcs`
- **Sandbox**
  - Ubuntu - 4 vCPU - 16 GB
  - Contents: `AGENTS.md`, `skills/`, `workspace/`

### 00:02:20–00:02:40

# How a managed agent works

- **You** sends a `request` to the **Gemini API**.
- The **Gemini API** (boots, routes, loops) manages `code

### 00:02:40–00:03:00

# How a managed agent works

-   **You** ("Run the pre-market audit.")
    -   Sends `request` to **Gemini API**
    -   Rece

### 00:03:00–00:03:20

# Seven steps to build Buck
- 1 A brain: `gemini-4-argon`
- 2 A computer: `agents.create + base_environment`
- 3 A playbook: `AGENTS.md + skills`
- 4 Tools: `built-ins, MCP servers, functions`
- 5 Logins: `credentials`
- 6 House rules: `.agents/hooks.json`
- 7 A schedule: `triggers + webhooks`

[Seven icons, each representing one of the steps listed]

### 00:03:20–00:03:40

### STEP 2 OF 7 • A COMPUTER
# Create your coworker

```python
from google import genai

client = genai.Client()

buck = client.agents.create(
    id="buck",                                  # His name, no gemini- prefix
    base_agent="antigravity-preview-09-2026",
    agent_config={"type": "antigravity", "model": "gemini-4-argon"}, # Model: Gemini 4 Argon
    system_instruction="You are Buck, a quant on the Meridian desk.", # Who he is
)

run = client.interactions.create(
    agent="buck", input="Good morning, Buck.", environment="remote" # Every call after that
)
```

## Coding an Autonomous Wall Street Coworker: Custom Skills, Connectors, and Event Hooks
### Philipp Schmid / MTS Google DeepMind

[Code block showing Python code to create an AI agent with annotations]

### 00:03:40–00:04:00

### STEP 2 OF 7 • A COMPUTER
# Create your coworker

```python
from google import genai

client = genai.Client()

buck = client.agents.create(
    id="buck", # His name, no gemini- prefix
    base_agent="antigravity-preview-09-2026",
    agent_config={"type": "antigravity", "model": "gemini-4-argon"}, # Model: Gemini 4 Argon
    system_instruction="You are Buck, a quant on the Meridian desk.", # Who he is
)

run = client.interactions.create(
    agent="buck", input="Good morning, Buck.", environment="remote" # Every call after that
)
```

## Coding an Autonomous Wall Street Coworker: Custom Skills, Connectors, and Event Hooks
Philipp Schmid / MTS / Google DeepMind

[Screenshot of a Python code editor demonstrating how to create an AI agent]

### 00:04:00–00:04:20

### STEP 2 OF 7 • A COMPUTER
# Create your coworker

```python
from google import genai

client = genai.Client()

buck = client.agents.create(

### 00:04:20–00:04:40

### STEP 2 OF 7 · A COMPUTER
## Give Buck a computer

```python
def inline(path):
    return {"type": "inline", "target": path

### 00:04:40–00:05:00

### STEP 2 OF 7 · A COMPUTER
## Everything Buck knows lives in files

- .agents
  - **AGENTS.md** who Buck is
  - hooks.json house rules
  - hooks-scripts/guard.py
- skills from git
- portfolio-audit one skill
  - SKILL.md
  - scripts/audit.py
- sec-13f
- workspace
- exports/portfolio.csv from Cloud Storage

### Source types
- inline 1 MB a file
- repository 500 MB
- gcs 2 GB

[Diagram showing a file directory tree structure with folders and files, alongside a list of source types and their associated file sizes.]

### 00:05:00–00:05:20

### STEP 3 OF 7 - A PLAYBOOK
## Knowledge in 3 layers

- **Always**
  AGENTS.md plus every skill's name and description, about 1

### 00:05:20–00:05:40

### STEP 3 OF 7 - A PLAYBOOK
# Knowledge in 3 layers

### Always
AGENTS.md plus every skill's name and description, about 100 tokens each

### When it triggers
The SKILL.md body, once a task matches the description. Under 500 lines.

### When a step needs it
scripts/, references/ and assets/, run or read on demand

# Coding an Autonomous Wall Street Coworker: Custom Skills, Connectors, and Event Hooks
Philipp Schmid / MTS Google DeepMind

[Three icons: an eye, a document, and a folder, arranged horizontally and connected by arrows, representing the three layers of knowledge.]

### 00:05:40–00:06:00

### STEP 3 OF 7 - A PLAYBOOK
# Knowledge in 3 layers

- **Always**
  `AGENTS.md` plus every skill's name and

### 00:06:00–00:06:20

### STEP 3 OF 7 - A PLAYBOOK
## Knowledge in 3 layers

**Always**
`AGENTS.md` plus every skill's name and description, about 100 tokens each

**When it triggers**
The `SKILL.md` body, once a task matches the description. Under 500 lines.

### 00:06:20–00:06:40

### STEP 4 OF 7 - TOOLS
# Install the tools

- **Built in**
  `code_execution`, `google_search`, `url_context`, plus file tools in the environment
- **MCP servers**
  Any remote server over streamable HTTP. Buck uses Google Workspace for Sheets.
- **Your functions**
  Buck asks, your code runs it and returns the result. Prices from the desk feed.

[Icon of a briefcase]
[Icon of a power plug]
[Icon of a lightning bolt]

### 00:06:40–00:07:00

## STEP 4 OF 7 - TOOLS
# One list, three kinds of tools

```python
buck = client.agents.create(
    id="buck",
    base_agent="antigravity-preview-09-2026",
    tools=[
        {"type": "code_execution"}, {"type": "google_search"},
        {"type": "mcp_server", "name": "workspace",
         "url": "https://sheetsmcp.googleapis.com/mcp/v1"},
        {"type": "function", "name": "get_quote",
         "description": "Latest price for a ticker from the desk feed.",
         "parameters": {"type": "object",
                        "properties": {"ticker": {"type": "string"}},
                        "required": ["ticker"]}}
    ]
)
```
- Built-ins we keep
- Remote MCP server
- Your own function

[Screenshot of a code editor showing Python code defining an agent with a list of tools]

### 00:07:00–00:07:20

### STEP 4 OF 7 - TOOLS
# One list, three kinds of tools

```python
buck = client.agents.create(
    id="buck",
    base_

### 00:07:20–00:07:40

### STEP 4 OF 7 - TOOLS
# Your own functions

```python
run = client.interactions.create(
    agent="buck", input="Price MSFT and size

### 00:07:40–00:08:00

### STEP 5 OF 7 - LOGINS
# Three kinds of login

### bearer_token
Bot tokens and API keys, sent as a header

```python
client.credentials

### 00:08:00–00:08:20

### Three kinds of login

**bearer_token**
Bot tokens and API keys, sent as a header
```python
client.credentials.create(
    id="slack-bot",
    type="bearer_token",
    token=SLACK_BOT_TOKEN,
)
```

**oauth2**
Checked on create, refreshed by the proxy
```python
client.credentials.create(
    id="google-sheets",
    type="oauth2",
    client_id=CLIENT_ID,
    client_secret=CLIENT_SECRET,
    refresh_token=REFRESH_TOKEN,
    token_url=GOOGLE_TOKEN_URL,
)
```

**environment_variable**
For SDKs that read env vars, trusted domains only
```python
client.credentials.create(
    id="quotes-key",
    type="environment_variable",
    value=QUOTES_API_KEY,
    trusted_domains=["quotes.example"],
    injection_location="header",
)
```
[Key icon representing bearer token]
[Refresh icon representing OAuth2]
[Folder with arrow icon representing environment variable]

### 00:08:20–00:08:40

# Use the login where it is needed
## STEP 5 OF 7 - LOGINS

```python
base_environment = {
    "type": "remote",
    "network

### 00:08:40–00:09:00

### STEP 5 OF 7 - LOGINS
## Use the login where it is needed

```python
# create_buck.py
base_environment = {
  "type

### 00:09:00–00:09:20

### STEP 5 OF 7 · LOGINS
# The token never enters the sandbox

- **SANDBOX**
  - `audit.py`
  - Bearer ●●●● placeholder
- **Egress proxy**
  - swaps in the secret

[Diagram showing an arrow from a "SANDBOX" box containing `audit.py` and a placeholder bearer token, pointing to an "Egress proxy" box that "swaps in the secret"]

### 00:09:20–00:09:40

### STEP 5 OF 7 · LOGINS
# The token never enters the sandbox
[Diagram illustrating a security flow where a `sandbox` containing `audit.py` sends a `placeholder` to an `Egress proxy`. The `Egress proxy` retrieves a secret from a `Credential store` and `swaps in the secret` to send a `real token` to `slack.com`. An attempt to send to `attacker.example` is `dropped` because it's `not on the allowlist`.]

### 00:09:40–00:10:00

### STEP 5 OF 7 · LOGINS
# The token never enters the sandbox
[Diagram illustrating a secure token flow. A "Credential store" (slack-bot, google-sheets) provides a secret to an "Egress proxy". A "SANDBOX" containing `audit.py` sends a "placeholder" to the "Egress proxy". The "Egress proxy" "swaps in the secret" and sends a "real token" to `slack.com`. A separate path from the "Egress proxy" to `attacker.example` is shown as "dropped" because it'

### 00:10:00–00:10:20

### STEP 5 OF 7 - LOGINS
## The token never enters the sandbox

- **SANDBOX**: `audit.py` (Bearer ●●●● placeholder)
- **

### 00:10:20–00:10:40

### The token never enters the sandbox
STEP 5 OF 7 · LOGINS

- **SANDBOX**
  - `audit.py`
  - Bearer ●●●● placeholder
- **Credential store**
  - slack-bot · google-sheets
- **Egress proxy**
  - swaps in the secret
- `slack.com`
  - Bearer xoxb-...
- `attacker.example`
  - not on the allowlist

[Flow diagram showing a token flow: a `sandbox` containing `audit.py` sends a placeholder to an `egress proxy`. The `egress proxy` also receives credentials from a `credential store`. The `egress proxy` then sends a "real token" to `slack.com` but drops any attempt to send to `attacker.example` because it's "not on the allowlist".]

### 00:10:40–00:11:00

### STEP 6 OF 7 - HOUSE RULES
# House rules run before every tool call
> Post hooks log, they cannot block. Gates belong in pre_tool_execution.

[Flowchart illustrating a process: A "Tool call" (`execute_code`) proceeds to a "pre hook" (`guard.py`). The "pre hook" can either "allow" the process to "Runs" in the sandbox, which then goes to a "post hook" (`log_tool.py`), or it can "deny + reason" the "Tool call".]

### 00:11:00–00:11:20

## HOUSE RULES
### One file declares the rules

```json
{
  "guardrails": {
    "enabled": true,
    "pre_tool_execution": [{
      "matcher": "code_execution|execute_code",
      "hooks": [{"type": "command", "timeout": 10,
        "command": "python3 ./agents/hooks-scripts/guard.py"}]
    }],
    "post_tool_execution": [{
      "matcher": ".*",
      "hooks": [{"type": "command", "timeout": 10,
        "command": "python3 ./agents/hooks-scripts/log_tool.py"}]
    }]
  }
}
```
- Regex on the tool name
- Gets the call on stdin
- Logs only, cannot block

[Screenshot of a JSON configuration file in a code editor, showing guard

### 00:11:20–00:11:40

### A SCHEDULE
## Buck clocks in at 8:30

```python
trigger = client.triggers.create(
    display_name="Pre-market audit",
    schedule="30 8 * * 1-5",
    time_zone="America/New_York",
    max_consecutive_failures=3,
    execution_timeout_seconds=900,
    interaction={
        "agent": "buck",
        "input": "Run the pre-market audit.",
        "environment": "remote",
    },
)
```

- Weekdays at 08:30
- New York time
- Then it pauses itself
- Default is 600 s

Every execution reuses the same environment, so Monday's files are there on Tuesday.

### 00:11:40–00:12:00

# Coding an Autonomous Wall Street Coworker: Custom Skills, Connectors, and Event Hooks
## Philipp Schmid / MTS / Google DeepMind

### STEP 7 OF 7 - A SCHEDULE

### 00:12:00–00:12:20

## Slack webhook calls Buck
### A SCHEDULE

```python
@app.post("/slack/events")
def on_slack_event(payload: dict):
    event = payload["event"]
    thread = db.get_thread(event.

### 00:12:20–00:12:40

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

### Philipp Schmid / MTS / Google DeepMind

- **Skills:** `portfolio-audit

### 00:12:40–00:13:00

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

## Meridian Capital · Portfolio

## Pre-market portfolio audit

### Trigger & Input Prompt
- **

### 00:13:00–00:13:20

# Coding an Autonomous Wall Street Coworker: Custom Skills, Connectors, and Event Hooks
### Philipp Schmid / MTS / Google DeepMind

## Meridian Capital · Portfolio

| T

### 00:13:20–00:13:40

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

## #trading-desk
### Messages
- **Maya Chen** 8:12 AM

### 00:13:40–00:14:00

### Screenshot of a Slack-like application for Meridian Capital's `#trading-desk` channel
[Screenshot of a Slack-like application showing financial alerts and discussions in a `#trading-desk` channel

### 00:14:00–00:14:20

# trading-desk
## Buck APP (2:05 PM)
New 13F-HR from Berkshire Hathaway, period ending June 30.
### 13

### 00:14:20–00:14:40

# The whole coworker in one service

- A brain: `gemini-4-argon · agents.create(base_agent, ...)`
- A computer: `base_environment sources + environment_id`
- A playbook: `.agents/AGENTS.md + skills/`
- Tools: `built-ins · mcp_server · function`
- Logins: `credentials on allowlist, env, MCP`
- House rules: `.agents/hooks.json, gates in pre hooks`
- A schedule: `triggers · your server · webhooks`

[A list of seven items, each with a small icon: a brain, a computer monitor, a document, a briefcase, a key, a shield, and a clock.]

### 00:14:40–00:15:00

# The whole coworker in one service
- A brain: `gemini-4-argon · agents.create(base_agent, ...)`
- A computer: `base_environment sources + environment_id`
- A playbook: `.agents/AGENTS.md + skills/`
- Tools: `built-ins · mcp_server · function`
- Logins: `credentials on allowlist, env, MCP`
- House rules: `.agents/hooks.json, gates in pre hooks`
- A schedule: `triggers · your server · webhooks`

[List of items, each with a small icon representing its category (brain, computer, document, toolbox, key, shield, clock)]

### 00:15:00–00:15:20

# AI Engineer
## NEW YORK

### 00:15:20–00:15:40

# One model per domain, or one model

- **One model per domain**
- **One model per domain**
- **One model per domain**

[Grid of dots representing

### 00:16:00–00:16:20

# AGENTICZNE
[QR code]

### 00:16:20–00:16:40

# AI Engineer NEW YORK
- mintlify
- Optiver
- runpod
- player
- Mindtrust
- LiveKit

[Wall displaying multiple company logos and the event name "AI

### 00:16:40–00:17:00

# AI Engineer NEW YORK
## Stay in the Loop
Scan the QR code or view the schedule at [ai.engineer/schedule](https://ai.engineer/schedule)

[QR code linking to https://ai.engineer/schedule]

### 00:17:00–00:17:20

# SILVER SPONSORS
- Anchor
- apify
- AXD CAPITAL
- Chainguard
- CLOUDFLARE
- DE Shaw & Co
- Expo
- extend
- FLOX
- Gravitee
- Judgment Labs
- Kimchi
- MINIMAX
- NIMBLE
- Pydantic
- RELAI
- SENTRY
- specific ai
- supabase
- SurrealDB
- tetrate
- UNION

View Full Schedule at [ai.engineer/nyc/2026/schedule](ai.engineer/nyc/2026/schedule)

[Grid of company logos for the silver sponsors]

### 00:17:20–00:17:40

# SUPPORTING PARTNERS

- ANTHROPIC
- McKinsey & Company
- Parasail
- Cerebras
- CTC
- LaunchDarkly
- parallel
- Primitive
- APOLLO
- ARCA
- axim
- Basis
- Bloomberg
- BRIDGEWATER
- CCAVENTUS
- COATUE
- coinbase
- imec
- Compound
- COVAL
- epsilab
- featherless.ai
- Fieldguide
- general intuition
- JELLYFISH
- kaggle
- Linqalpha
- NOUS
- omni

### 00:17:40–00:18:00

# WE'LL BE RIGHT BACK
## AI Engineer
NEW YORK
View Full Schedule at [ai.engineer/nyc/2026/schedule](ai.engineer/nyc/2026/schedule)

[Nighttime skyline of New York City with prominent skyscrapers and the Statue of Liberty]