# 7 Things Your AI Coworker Needs - Philipp Schmid, Google DeepMind

Philipp Schmid, Google DeepMind

[Talk page](https://ai.engineer/talks/EtZwTYahfek-7-things-your-ai-coworker-needs) · [Video](https://www.youtube.com/watch?v=EtZwTYahfek)

## Building Bug, a Gemini coworker for the 8:30 portfolio audit

Philipp Schmid of Google DeepMind builds a finance agent that can run a Python audit on its own computer, update a Google Sheet, and explain three portfolio positions when someone follows up in Slack.

### What a coworker needs to finish a job after you leave

[0:00](https://www.youtube.com/watch?v=EtZwTYahfek&t=0s)

Philipp Schmid starts with a change in what it means to give an AI work. Two years earlier, his examples were questions a model could answer in a chat box, such as naming the capital of France or the winner of the last European Championship. Coding assistants took a further step. They could use tools and write code on the user's computer. The finance coworker Schmid wants to build should be able to take an assignment on its own computer and have a result ready when the person who assigned it comes back hours later.

Schmid borrows seven requirements from onboarding a human colleague. The first two are a brain to do the work and a computer on which to save artifacts and iterate. A capable new hire still needs a playbook for the team's particular workflows. Tools and credentials come separately because knowing which piece of software to use only gets someone as far as its login. House rules specify what the coworker may do independently and where someone else must approve a decision. A schedule tells it when to start.

![Seven illustrated requirements appear in two rows. The top row covers a brain, a computer, a playbook and tools. The bottom row covers logins, house rules and a schedule.](https://ai.engineer/api/talk-essay-media/c6605b658e036837d6c9f7b65288b287b590fe1fc248d064e65cb927fe7ee8ed)

What a coworker needs to do the job

The assignment that ties those requirements together is a recurring portfolio audit. An agent has to recognize the procedure, check what changed, and leave its findings somewhere the team already works. Someone should then be able to ask about the findings. Producing the morning spreadsheet and answering the subsequent question are related jobs, but they need different instructions, tools, and context.

### Gemini 4 supplies the reasoning, with room for longer outputs

[1:50](https://www.youtube.com/watch?v=EtZwTYahfek&t=110s)

Schmid introduces Gemini 4 Argon, which he says Google announced the previous day. He singles out its one-million-token unified context window. The detail he emphasizes is on the output side. Gemini can generate up to one million tokens, giving it room to work beyond 64K tokens on a long reasoning problem. He reports improvements in mathematics, where working through a proof and putting the result into the required form can both draw on that capacity. His entry point for trying the model is the Interactions API. Get an API key in AI Studio, then send a request, an example he describes as four lines of code.

![A Python example sends Gemini 4 Argon a question about portfolio drift and prints the response. Three notes beside the code cover thinking levels, long outputs and token pricing.](https://ai.engineer/api/talk-essay-media/b0371de9554013ba2cd85295abdfce4528c25edc241ca8b0976c1d4248c8dd21)

One request to Gemini 4 Argon

Google employees had a few weeks of internal access. Schmid credits the model with helping the Chrome team accelerate work to decouple parts of Chromium, helping the Gemma team make its open model more efficient to run, and helping the Cloud ADK team improve its framework. He also reports improvements on Google's internal codebase, without giving a benchmark score or a timing comparison for those projects.

A colleague's experiment makes the kind of assignment Schmid has in mind easier to picture. The colleague prompted Gemini to build a custom 3D ray tracer, and Gemini produced the renderer entirely in Python. The demo paired the renderer with an explanatory voiceover, using Gemini text-to-speech and Lyria for the audio. For the portfolio job, the next question is where a model that can write a program actually gets to run one.

### Move execution into a sandbox, then give Bug an agent ID

[4:26](https://www.youtube.com/watch?v=EtZwTYahfek&t=266s)

In a conventional tool-calling loop, an application sends a request to the model and may receive a JSON function call. At that point the application has a description of an operation. It must find the corresponding function, execute it on a machine it controls, and send the result back to the model. If the operation writes a file, the application's execution environment determines where that file goes. The application sits in the middle of the next tool call as well.

The Gemini API's Managed Agents service gives Gemini a remote sandbox where it can execute code and write files directly. Schmid first describes invoking an existing agent. Where an ordinary model request identifies the model, this request identifies an agent, supplies a prompt, and selects the managed sandbox as its remote environment. The caller can initiate work with an API request while the agent uses its own computer for the operations that follow.

![Arrows connect the user, Gemini API, Gemini 4 Argon and an Ubuntu sandbox. The API sends context to the model, receives a tool call, executes it in the sandbox and receives results. Three sources feed the sandbox.](https://ai.engineer/api/talk-essay-media/144aad7cc897ded3111e825d17f413d401eb3eaf649456cc68856fa1bf4817e7)

How a managed agent works

Schmid then defines his own coworker, Bug. The agent creation API takes an ID, the name callers will later use to address Bug. The definition selects an underlying agent harness, a model, and system instructions. Schmid chooses the same harness used in Antigravity and the new Gemini model. These choices have distinct jobs. Gemini reasons about what to do, the harness lets it act on the remote computer, and the ID gives callers a way to request work from that configured combination.

### Divide the playbook by when Bug needs to read it

[6:56](https://www.youtube.com/watch?v=EtZwTYahfek&t=416s)

Skills, hooks, and system instructions all have a file representation in the managed environment. A developer can give Bug a skill they already use with a local agent. Bug can also use its filesystem for knowledge it acquires, saving a lesson from an earlier session or creating a skill for a procedure it expects to repeat. A file on the computer can remain available between tasks without its entire contents having to accompany every request.

Schmid divides the knowledge into three categories. First come system instructions, the material Bug needs on every request. Brevity here has a recurring payoff because the caller pays for those tokens each time. Second come skills that Bug can select for a particular assignment. A short description gives it enough information to recognize when a skill applies. Once it recognizes an audit request, it can open the relevant skill and read the procedure.

Third come dedicated references and scripts for individual steps. Selection alone solves only part of the context problem. If every audit requires opening one dense skill, the model still incurs that cost every time it selects the audit. A shorter procedure can direct Bug to the particular reference it needs or to a script it can execute. That also leaves a Slack follow-up free to use the thread history without carrying the full audit procedure on every turn.

The portfolio-audit skill shows what belongs in the procedure. Its description tells Bug when to use it. Its instructions tell Bug how to run a supplied Python script, what to do with the result, and where to store it. Those last instructions connect a successful calculation to the team's deliverable. The script can finish on the remote computer while the work of recording the result in the spreadsheet is still outstanding.

![A portfolio audit skill file highlights the description that tells Buck when to use it and the instruction to run the audit script. A callout reports about 50% better triggering after rewriting the description.](https://ai.engineer/api/talk-essay-media/f82bcc6f3fed22fc130103a51acb59f73cc70e29a0d769d0eae564fc43c545ae)

An example skill

### Choose among built-in tools, MCP servers, and application functions

[8:47](https://www.youtube.com/watch?v=EtZwTYahfek&t=527s)

Schmid extends the agent creation request to declare Bug's tools. The first option is a built-in capability. Google Search is available through the Gemini API, so enabling it requires no separate search integration. Code execution gives Bug a way to run the audit script on its own computer. These capabilities cover looking something up or doing local computation, while writing the findings into the team's spreadsheet requires access to an external service.

The second option is a Model Context Protocol (MCP) server. Schmid points to Google Workspace's MCP server, which exposes operations for services including Gmail and spreadsheets. For this job, the relevant capability is spreadsheet access. A developer can also supply an MCP server of their own to expose another service or data provider to the agent.

The third option is an application-owned function. Bug generates the function call, the application runs it, and the application sends the function result back. This preserves a useful part of the conventional loop. If a particular operation belongs on a computer the developer controls, the developer can take responsibility for that operation alone. Bug can still run Python and work with its files in the managed sandbox.

![Python code shows Buck requesting an MSFT quote. The server runs get_quote and returns the result with the matching call ID, continuing in the same conversation and environment.](https://ai.engineer/api/talk-essay-media/afefa5fd087dc33c19a5d49ec4c02cd7534b6764538cdf98c13aae8b10df9d52)

Your own functions

### Let Bug authenticate without putting the real token on its computer

[9:57](https://www.youtube.com/watch?v=EtZwTYahfek&t=597s)

Credentials are the onboarding step Schmid is most interested in because agents make a familiar integration practice easy to get wrong. Managed Agents accommodates three interfaces. A normal API call can use a bearer token. A consumer-facing integration, including an MCP tool, can use OAuth. A CLI that expects to discover its login in an environment variable can keep using that interface. The developer creates the credential outside the sandbox and defines where and how the agent may use it.

The credential store is write-only from the developer's perspective. Once a value has been written, the interface allows it to be overwritten for rotation but offers no readback. In Schmid's Slack example, the developer supplies a credential and configures its permitted domain and how it will be presented. That configuration matters at request time, when an external network proxy inspects traffic crossing the sandbox boundary.

Consider the environment-variable case from the CLI's perspective. The expected variable is set, so the CLI can read it and build its request as usual. Inside the sandbox, its value is a dummy. When the request reaches the proxy, the proxy checks the destination against the developer's configuration. For a matching domain it substitutes the real credential and forwards the request. The service authenticates it and sends back a result that Bug can use. The CLI has followed its ordinary login path without needing access to the real value.

Schmid illustrates the boundary with two attempts to steal a key. A prompt injection might persuade an agent to print the contents of its `.env` file. With the proxy arrangement, inspecting the configured variable exposes the dummy. A malicious MCP server might try to collect a Gmail token by getting the agent to send it there. The proxy substitutes the Gmail credential only on requests to its configured domain. Bug can still make authenticated requests to permitted services, and some of those operations may warrant approval.

![Inside the sandbox, audit.py sends a placeholder to the egress proxy. The proxy takes the secret from the credential store. A green arrow carries the real token to slack.com, and a dashed red arrow marks the dropped request to attacker.example.](https://ai.engineer/api/talk-essay-media/434aba794670a4f395da4ad53314fef95b5408d3cea7036c900cdd99b19226de)

The token never enters the sandbox

### Enforce command approvals with protected hook files

[12:54](https://www.youtube.com/watch?v=EtZwTYahfek&t=774s)

For an operation that needs monitoring or human approval, Schmid uses a hook. The developer defines a matcher as a regular expression. The harness checks each proposed tool call against the matcher and runs the associated hook on a match. That gives the developer a place to require a human decision outside the agent's ordinary conversation. Enforcement depends on the harness seeing the specified call, so the matcher must describe the operation the developer intends to guard.

![A code panel shows .agents/hooks.json. Two highlighted lines identify the tool-name pattern and the guard.py command. Annotations explain how the command receives the call and what the post hook can do.](https://ai.engineer/api/talk-essay-media/e68a6091c8d3b8eaa64107c32f2946da665b624ba217e2ec1e71b14d735d0a5c)

One file declares the rules

A hook is a file, just as a skill is, but Bug's permissions differ. Bug may write a new skill as it learns how to carry out a procedure. Its hook files are protected against edits by the agent. That separation allows Bug to improve the instructions it follows while leaving control over which commands need review with the person who configured it.

### Attach an input and an environment to a cron schedule

[13:36](https://www.youtube.com/watch?v=EtZwTYahfek&t=816s)

The final requirement is a way to start work without waiting for a person to type a prompt. At the time Schmid demonstrates Bug, Managed Agents supports cron triggers. The developer specifies a schedule and the input the agent should receive. The trigger runs the assignment in the same environment, where the relevant files and tools are available. A periodic due-diligence check and a daily audit can use this mechanism with different inputs and cadences.

![In schedule.py, four highlighted settings schedule Buck’s pre-market audit for 08:30 on weekdays in New York, pause it after three consecutive failures, and set a 900-second timeout. A note below says files persist between runs.](https://ai.engineer/api/talk-essay-media/9c6dcd99b0b6cc741db9fc5ee016c938bcd86c18447e8f85e8bd6fd1a2eed1b8)

Buck clocks in at 8:30

Schmid also sketches an event-driven version under development. An external provider could call a webhook, the agent could perform an initial audit, and it could report to Slack or Microsoft Teams. He identifies external webhooks as work in progress. The portfolio demonstration uses the cron design, with a manual way to exercise it in front of an audience.

### Follow one audit from the simulated timer to the Slack thread

[14:31](https://www.youtube.com/watch?v=EtZwTYahfek&t=871s)

Schmid asked Gemini to help him build a browser replica of Google Sheets for the demonstration. He clicks a control in that interface to simulate the scheduled trigger. The click sends a real request to the Managed Agents API. This lets the audience follow the work that an 8:30 a.m. trigger would initiate without waiting for the scheduled time.

Bug's first visible decision is to read the portfolio-audit skill. Once the instructions come back, it works through calls to financial services to determine whether the market or a stock price has changed. Schmid points out an initial result while the run is still in progress, then reports that Bug updates the Google Sheet. The sequence matters for reconstructing the job. The trigger supplies the assignment, the skill supplies the procedure, the services supply the observations, and the spreadsheet is where the result becomes available to the team.

With Slack access, Bug could also post what changed to a designated trading channel. Schmid demonstrates the follow-up by asking for a recommendation. After a short wait, the reply discusses three positions. He attributes that specificity to the previous turns in the Slack thread, which are available to the agent when it answers. The recording gives the count but does not identify the holdings or their price changes. Bug explains what changed and takes no further action, behavior Schmid attributes to its system instructions.

![A sequence diagram follows an analyst’s question about NVDA through Slack to the server. The server passes the previous interaction ID and environment to Buck, who reads audit.json and returns an answer to the server.](https://ai.engineer/api/talk-essay-media/227959df1772f4d9ea4453932e22cd3bbc7b5e38ca5dc83ae394a197b1c60295)

Every thread is one conversation

The sheet update and the Slack reply show two scopes of autonomy in the same coworker. Bug has a standing assignment to record audit results. A question about those results gives it conversational context for an explanation, while its instructions govern what it does next. The scheduled run, remote execution, and access to the configured services all come through the Managed Agents environment.

## Key takeaways

- Write the audit skill through to its destination. Tell the agent when to select it, which script to run, how to interpret the result, and where to record it.
- Choose the execution location per operation. Bug can run Python in its sandbox, use MCP for a spreadsheet, and return a function call to the application for work that belongs on another machine.
- Configure credential destinations and command approvals separately. The proxy determines where a real token can be used. A protected hook determines when a matching tool call needs review.
- Exercise a scheduled job by sending its real input on demand. Follow it through the skill read, service calls, and destination update, then test a follow-up with the thread context the user will actually have.

## Slides

### From chatbot to coworker

[0:21](https://www.youtube.com/watch?v=EtZwTYahfek&t=21s) [Arrows connect three panels from left to right. Chat bubbles represent a chatbot answering a question, a terminal represents an assistant using tools, and a highlighted task represents a coworker reporting back.](https://assets.ai.engineer/sites/aiecode2025/sha256/a2fb8f4499fa42a2a7f657a2756c352e0f5c6773ba26e46f8ec64d74982433b2.webp)

From chatbot to coworker

Chatbot
Answers when you ask

Assistant
Uses tools while you watch

Coworker
Owns a task or goal and reports back

### What a coworker needs to do the job

[0:55](https://www.youtube.com/watch?v=EtZwTYahfek&t=55s) [Seven illustrated requirements appear in two rows. The top row covers a brain, a computer, a playbook and tools. The bottom row covers logins, house rules and a schedule.](https://assets.ai.engineer/sites/aiecode2025/sha256/c6605b658e036837d6c9f7b65288b287b590fe1fc248d064e65cb927fe7ee8ed.webp)

What a coworker needs to do the job

A brain
Plans the work, decides and explains why

A computer
Their own machine with their files

A playbook
How to run checks, fill out forms and write reports

Tools
Search, spreadsheets, internal apps

Logins
Access to systems, spreadsheets and documents

House rules
What needs a check before it happens

A schedule
Work that starts without being asked

### Gemini 4 Argon is the brain

[1:53](https://www.youtube.com/watch?v=EtZwTYahfek&t=113s) [Large figures on the left highlight a 1M-token window and 100k+ daily users at Google before launch. A table on the right compares four models, with Gemini 4 Argon leading both displayed benchmarks.](https://assets.ai.engineer/sites/aiecode2025/sha256/ed1e8c61861e3d7c3cd8001917a96143ff71ee3a2f45ab17192a4db26d851286.webp)

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

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

100k+
Googlers used it daily for a month before launch

#1 on Vals Index · Finance, coding, legal & tax
Model	Vals Index	Finance Agent v2
Gemini 4 Argon	68.9%	65.4%
Claude Opus 5.5	67.0%	58.6%
Claude Fable 5.1	65.8%	58.9%
GPT-6 Astra	63.1%	53.5%

Vals Index: Agentic model performance across finance, coding, legal, and tax tasks, weighted by each sector's share of U.S. GDP.
Finance Agent v2: Multi-step financial reasoning tasks.

### One request to Gemini 4 Argon

[2:38](https://www.youtube.com/watch?v=EtZwTYahfek&t=158s) [A Python example sends Gemini 4 Argon a question about portfolio drift and prints the response. Three notes beside the code cover thinking levels, long outputs and token pricing.](https://assets.ai.engineer/sites/aiecode2025/sha256/b0371de9554013ba2cd85295abdfce4528c25edc241ca8b0976c1d4248c8dd21.webp)

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

hello_argon.py
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.

### What Googlers have done so far

[3:11](https://www.youtube.com/watch?v=EtZwTYahfek&t=191s) [Six illustrated examples in a three-column grid report results from Chromium, Gemma inference, ADK session preparation, chemistry structure prediction, enzyme design and code submissions across Google.](https://assets.ai.engineer/sites/aiecode2025/sha256/361f8c2259f4e7637db4f608293cde025fdf2bc6c486fe7c2e36b4ab42151978.webp)

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

### Pure-Python 3D ray tracer

[3:57](https://www.youtube.com/watch?v=EtZwTYahfek&t=237s) [An embedded render shows sunlight crossing a room with bookshelves, an orange chair and a low table. A wall of windows overlooks water and distant hills.](https://assets.ai.engineer/sites/aiecode2025/sha256/5b283ad6fee0f6f22186a4b49ac5232f6a92904eb61962b8b510e8fe60e2daa9.webp)

GEMINI 4 ARGON
Pure-Python 3D ray tracer

5,500 lines of Python & NumPy · zero 3D libraries
Rendering a 3D scene with vanilla Python
5,500 lines of Python & NumPy ray-tracing every surface, shadow, and refraction from scratch.

STAGE 14 / FULL-ROOM RAY TRACE

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.

### How a managed agent works

[4:27](https://www.youtube.com/watch?v=EtZwTYahfek&t=267s) [Arrows connect the user, Gemini API, Gemini 4 Argon and an Ubuntu sandbox. The API sends context to the model, receives a tool call, executes it in the sandbox and receives results. Three sources feed the sandbox.](https://assets.ai.engineer/sites/aiecode2025/sha256/144aad7cc897ded3111e825d17f413d401eb3eaf649456cc68856fa1bf4817e7.webp)

How a managed agent works

You
“Run the pre-market audit.”
request     response

Gemini API
boots, routes, loops
code_execution     filesystem     skills

context     tool call
Gemini 4 Argon
reasons, picks the next tool

execute
results

inline     repository     gcs
Sandbox
Ubuntu · 4 vCPU · 16 GB
AGENTS.md     skills/     workspace/

The API runs this loop until the task is done. You see the request and the response.

Comment     9 / 33

### One call starts the loop

[5:11](https://www.youtube.com/watch?v=EtZwTYahfek&t=311s) [A Python example asks an agent to audit Portfolio_Master and flag drift over 2%. Highlighted lines select the agent and the remote environment.](https://assets.ai.engineer/sites/aiecode2025/sha256/234e233a1ef889fd481e05db809bc1a7626cced44b260f87e412cc14ad4a4e25.webp)

One call starts the loop

hello_buck.py
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    agent="antigravity-preview-09-2026",
    input="Audit Portfolio_Master and flag drift over 2%.",
    environment="remote",
)
print(interaction.output_text)

Comment     10 / 33

### Create your coworker

[5:41](https://www.youtube.com/watch?v=EtZwTYahfek&t=341s) [Highlighted Python lines define Buck’s ID, model and role as a quant on the Meridian desk. A second call addresses Buck by ID with “Good morning, Buck.”](https://assets.ai.engineer/sites/aiecode2025/sha256/ae7ef5a6d47c495e77cfefcb9a7e55df7e170487af93c620cf50d7e55fdca111.webp)

STEP 2 OF 7 · A COMPUTER
Create your coworker

create_buck.py
from google import genai

client = genai.Client()

buck = client.agents.create(
    id="buck",
    base_agent="antigravity-preview-09-2026",
    agent_config={"type": "antigravity", "model": "gemini-4-argon"},
    system_instruction="You are Buck, a quant on the Meridian desk.",
)

run = client.interactions.create(
    agent="buck", input="Good morning, Buck.", environment="remote"
)

His name, no gemini- prefix
Model: Gemini 4 Argon
Who he is
Every call after that

Comment     12 / 33

### Give Buck a computer

[6:30](https://www.youtube.com/watch?v=EtZwTYahfek&t=390s) [Python code configures Buck’s remote environment with inline instructions and hooks, skills from a Git repository, and daily exports from Cloud Storage. Callouts give the size limits for each source.](https://assets.ai.engineer/sites/aiecode2025/sha256/6ced8d77fe1e00adf3ef589e9ebb86489bca206d339812a81357ab0640e2c26c.webp)

STEP 2 OF 7 · A COMPUTER
Give Buck a computer

create_buck.py
def inline(path):
    return {"type": "inline", "target": path, "content": read(path)}

buck = client.agents.create(
    id="buck",
    base_agent="antigravity-preview-09-2026",
    base_environment={"type": "remote", "sources": [
        inline(".agents/AGENTS.md"),
        inline(".agents/hooks.json"),
        inline(".agents/hooks-scripts/guard.py"),
        {"type": "repository", "target": ".agents/skills",
         "source": "https://github.com/meridian-capital/buck-skills"},
        {"type": "gcs", "target": "/workspace/exports",
         "source": "gs://meridian-desk/exports"},
    ]},
)

Inline: 1 MB a file, 2 MB total
Who Buck is
Skills from git, up to 500 MB
Daily exports, up to 2 GB

Comment     13 / 33

### Everything Buck knows lives in files

[6:55](https://www.youtube.com/watch?v=EtZwTYahfek&t=415s) [A file tree highlights AGENTS.md and the portfolio-audit skill. The skill contains SKILL.md and an audit script, and the workspace contains a portfolio CSV from Cloud Storage. A sidebar lists source size limits.](https://assets.ai.engineer/sites/aiecode2025/sha256/6152c649dfc1579c3efbba189b0ec41c8e0d6d84b1aacaa73b9765d9d78598ed.webp)

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

Comment     14 / 33

### Knowledge in 3 layers

[7:16](https://www.youtube.com/watch?v=EtZwTYahfek&t=436s) [Arrows link three columns marked with an eye, a document and a folder. The columns show what Buck always sees, what loads when a task matches a skill, and which files a step can use on demand.](https://assets.ai.engineer/sites/aiecode2025/sha256/34cc213a56e87a8798688e880c42d6fac2bf587da69ed02da9acdb51ae418ae4.webp)

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.

Comment     15 / 33

### An example skill

[8:28](https://www.youtube.com/watch?v=EtZwTYahfek&t=508s) [A portfolio audit skill file highlights the description that tells Buck when to use it and the instruction to run the audit script. A callout reports about 50% better triggering after rewriting the description.](https://assets.ai.engineer/sites/aiecode2025/sha256/f82bcc6f3fed22fc130103a51acb59f73cc70e29a0d769d0eae564fc43c545ae.webp)

STEP 3 OF 7 · A PLAYBOOK
An example skill

.agents/skills/portfolio-audit/SKILL.md
---
name: portfolio-audit
description: Audit Portfolio_Master positions, weights and drift
  against target. Use for pre-market audits and rebalance checks.
  Do NOT use for 13F filings or for placing trades.
---
# Portfolio audit

- Run scripts/audit.py. Never hand-compute weights.
- Flag any position with absolute drift of 2 points or more.
- No Slack message until audit.py has written /workspace/verified.json.
- Update only columns C, D, E and G in rows 2 to 6, from audit.json.

What it does
When to use it
When not to
Exact steps live in a script

The description is the trigger. Rewriting it alone gave me about 50% better triggering.

Comment   16 / 33

### Install the tools

[8:44](https://www.youtube.com/watch?v=EtZwTYahfek&t=524s) [Three columns show the tools Buck can use, with examples of built-in search and code execution, a remote MCP server for Sheets, and a custom function for desk-feed prices.](https://assets.ai.engineer/sites/aiecode2025/sha256/2ac42cbe6c80aa2d911ff4d44735b3182d8c93719b83cff8e0cb1173fd3bceba.webp)

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.

Comment   17 / 33

### One list, three kinds of tools

[9:04](https://www.youtube.com/watch?v=EtZwTYahfek&t=544s) [An annotated Python tools list for Buck highlights two built-ins, a remote Sheets MCP server, and a get_quote function that requires a ticker string.](https://assets.ai.engineer/sites/aiecode2025/sha256/5971d5ddf3434aea9930d435019ddf853026058d5f95914d35c6a6f3bc055c6e.webp)

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

create_buck.py
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

Comment   18 / 33

### Your own functions

[9:33](https://www.youtube.com/watch?v=EtZwTYahfek&t=573s) [Python code shows Buck requesting an MSFT quote. The server runs get_quote and returns the result with the matching call ID, continuing in the same conversation and environment.](https://assets.ai.engineer/sites/aiecode2025/sha256/afefa5fd087dc33c19a5d49ec4c02cd7534b6764538cdf98c13aae8b10df9d52.webp)

STEP 4 OF 7 · TOOLS
Your own functions

desk_server.py
run = client.interactions.create(
    agent="buck", input="Price MSFT and size the gap.", environment="remote")

call = next(s for s in run.steps if s.type == "function_call")
quote = desk_feed.get_quote(**call.arguments)

run = client.interactions.create(
    agent="buck",
    previous_interaction_id=run.id,
    environment=run.environment_id,
    input=[{"type": "function_result", "name": call.name,
            "call_id": call.id, "result": quote}],
)

Buck stops and asks
Runs on your server
Same conversation & machine
Matched by call_id

Comment   19 / 33

### Three kinds of login

[9:57](https://www.youtube.com/watch?v=EtZwTYahfek&t=597s) [Three side-by-side code examples show a bearer token sent in a header, an OAuth2 login refreshed by the proxy, and an environment variable restricted to a trusted domain.](https://assets.ai.engineer/sites/aiecode2025/sha256/a8821272c439758e2a8547140fb1c0f7d8fb550db4527576635f87c432b53177.webp)

STEP 5 OF 7 · LOGINS
Three kinds of login

bearer_token
Bot tokens and API keys, sent as a header

client.credentials.create(
    id="slack-bot",
    type="bearer_token",
    token=SLACK_BOT_TOKEN,
)

oauth2
Checked on create, refreshed by the proxy

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

client.credentials.create(
    id="quotes-key",
    type="environment_variable",
    value=QUOTES_API_KEY,
    trusted_domains=["quotes.example"],
    injection_location="header",
)

Comment   20 / 33

### Use the login where it is needed

[10:42](https://www.youtube.com/watch?v=EtZwTYahfek&t=642s) [Annotations show where the proxy adds a Slack token, where the sandbox sees a placeholder, and where each Sheets MCP request uses its credential. A footer shows how to rotate a write-only secret.](https://assets.ai.engineer/sites/aiecode2025/sha256/9beb59dadb1d4f902155e108c989b54226e281553598d03bef1e6dda772f7610.webp)

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

create_buck.py
base_environment = {
    "type": "remote",
    "network": {"allowlist": [
        {"domain": "slack.com", "credential": "slack-bot"},
        {"domain": "data.sec.gov", "transform": {"User-Agent": SEC_UA}},
    ]},
    "env": {
        "QUOTES_API_KEY": {"credential": "quotes-key"},
    },
}
tools = [{"type": "mcp_server", "name": "workspace",
          "url": "https://sheetsmcp.googleapis.com/mcp/v1",
          "credential": "google-sheets"}]

Proxy adds the token
Sandbox sees a placeholder
On every MCP request

Secrets are write-only. Rotate with client.credentials.update(id="slack-bot", type="bearer_token", token=NEW), no
agent change.

Comment   21 / 33

### The token never enters the sandbox

[11:27](https://www.youtube.com/watch?v=EtZwTYahfek&t=687s) [Inside the sandbox, audit.py sends a placeholder to the egress proxy. The proxy takes the secret from the credential store. A green arrow carries the real token to slack.com, and a dashed red arrow marks the dropped request to attacker.example.](https://assets.ai.engineer/sites/aiecode2025/sha256/434aba794670a4f395da4ad53314fef95b5408d3cea7036c900cdd99b19226de.webp)

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

SANDBOX
audit.py
Bearer ●●●● placeholder

placeholder

Credential store
slack-bot · google-sheets

Egress proxy
swaps in the secret

real token
slack.com
Bearer xoxb-...

dropped
attacker.example
not on the allowlist

### House rules run before every tool call

[12:52](https://www.youtube.com/watch?v=EtZwTYahfek&t=772s) [The execute_code call reaches guard.py. The allow path continues to the sandbox and then to log_tool.py. A dashed arrow labeled “deny + reason” returns to the tool call.](https://assets.ai.engineer/sites/aiecode2025/sha256/00d2f049d16626a2c9e67bdf68ec6b124daa82420b013b5e035550b7ada78bec.webp)

STEP 6 OF 7 · HOUSE RULES
House rules run before every tool call

Tool call
execute_code

pre hook
guard.py

deny + reason
allow

Runs
in the sandbox

post hook
log_tool.py

Post hooks log, they cannot block. Gates belong in pre_tool_execution.

### One file declares the rules

[13:13](https://www.youtube.com/watch?v=EtZwTYahfek&t=793s) [A code panel shows .agents/hooks.json. Two highlighted lines identify the tool-name pattern and the guard.py command. Annotations explain how the command receives the call and what the post hook can do.](https://assets.ai.engineer/sites/aiecode2025/sha256/e68a6091c8d3b8eaa64107c32f2946da665b624ba217e2ec1e71b14d735d0a5c.webp)

STEP 6 OF 7 · HOUSE RULES
One file declares the rules

.agents/hooks.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

### Buck clocks in at 8:30

[13:35](https://www.youtube.com/watch?v=EtZwTYahfek&t=815s) [In schedule.py, four highlighted settings schedule Buck’s pre-market audit for 08:30 on weekdays in New York, pause it after three consecutive failures, and set a 900-second timeout. A note below says files persist between runs.](https://assets.ai.engineer/sites/aiecode2025/sha256/9c6dcd99b0b6cc741db9fc5ee016c938bcd86c18447e8f85e8bd6fd1a2eed1b8.webp)

STEP 7 OF 7 · A SCHEDULE
Buck clocks in at 8:30

schedule.py
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.

### Events reach your server first

[14:05](https://www.youtube.com/watch?v=EtZwTYahfek&t=845s) [Two paths converge on the server. It polls SEC EDGAR for a new 13F-HR or receives a signed Slack app_mention. The server verifies the event and starts Buck in the background.](https://assets.ai.engineer/sites/aiecode2025/sha256/300039fb0359347d2058f1160d0cb5733cd8d6f39043ed43e47efd03c0b5e242.webp)

STEP 7 OF 7 · A SCHEDULE
Events reach your server first

SEC EDGAR
new 13F-HR
poll

Slack Events API
app_mention
signed POST

Your server
verify, then start

background=True

Buck
background run

Triggers are cron only. background=True requires store=True.

### Every thread is one conversation

[14:27](https://www.youtube.com/watch?v=EtZwTYahfek&t=867s) [A sequence diagram follows an analyst’s question about NVDA through Slack to the server. The server passes the previous interaction ID and environment to Buck, who reads audit.json and returns an answer to the server.](https://assets.ai.engineer/sites/aiecode2025/sha256/227959df1772f4d9ea4453932e22cd3bbc7b5e38ca5dc83ae394a197b1c60295.webp)

STEP 7 OF 7 · A SCHEDULE
Every thread is one conversation

Analyst
Slack
Your server
Buck

@Buck why did NVDA drift?
app_mention
previous_interaction_id + environment
reads audit.json
answer

### The whole coworker in one service

[16:42](https://www.youtube.com/watch?v=EtZwTYahfek&t=1002s) [Seven rows pair colored icons and AI coworker needs with their implementation details, from the model used as a brain to the triggers used for scheduling.](https://assets.ai.engineer/sites/aiecode2025/sha256/68df8ca7302ec85a6579d238ad6e4da7c76baa54c5a845bc5bb51e4feee4940b.webp)

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

Live	Comment	32 / 33

## Full transcript

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

[0:17](https://www.youtube.com/watch?v=EtZwTYahfek&t=17s) so hopefully we have many finance people or like engineers working in finance here so quickly

[0:23](https://www.youtube.com/watch?v=EtZwTYahfek&t=23s) before we go into like right where we are coming from two years ago we basically had a chat box we

[0:29](https://www.youtube.com/watch?v=EtZwTYahfek&t=29s) asked some simple question like what's the capital of France like who won the last European Championship

[0:34](https://www.youtube.com/watch?v=EtZwTYahfek&t=34s) then we moved to assistance using tools on our own computer having the first coding agents writing code

[0:41](https://www.youtube.com/watch?v=EtZwTYahfek&t=41s) for us and now we are moving into like this autonomous co-worker area where we basically

[0:46](https://www.youtube.com/watch?v=EtZwTYahfek&t=46s) give and or create a digital employee where we give an agent its own computer give it a task and

[0:53](https://www.youtube.com/watch?v=EtZwTYahfek&t=53s) hopefully come back a few hours later with a good result. So what does a co-worker normally needs and

[1:00](https://www.youtube.com/watch?v=EtZwTYahfek&t=60s) I think that goes for AI and for us humans as well we need a brain to be able to do our work we need a

[1:07](https://www.youtube.com/watch?v=EtZwTYahfek&t=67s) computer where we can save artifacts we create where we can iterate we need some kind of a new

[1:14](https://www.youtube.com/watch?v=EtZwTYahfek&t=74s) playbook right when you hire someone new they are new to your environment to your domain you might have

[1:19](https://www.youtube.com/watch?v=EtZwTYahfek&t=79s) specific workflows so you need playbooks we need tools for them to be able to do that job they all need

[1:26](https://www.youtube.com/watch?v=EtZwTYahfek&t=86s) credentials in one or the other way then there might be some specific house rules on what you should do or

[1:32](https://www.youtube.com/watch?v=EtZwTYahfek&t=92s) what you should not do what you can do on your own or where you need to get some approvals and then of

[1:37](https://www.youtube.com/watch?v=EtZwTYahfek&t=97s) course there are hopefully some schedules for working hours when you can come in or when you have to work and

[1:45](https://www.youtube.com/watch?v=EtZwTYahfek&t=105s) the same goes for for our agents so and we are going to work through all of those seven steps and how

[1:50](https://www.youtube.com/watch?v=EtZwTYahfek&t=110s) you can build your own digital co-worker with Gemini in this talk but before we go in yesterday was the

[1:56](https://www.youtube.com/watch?v=EtZwTYahfek&t=116s) big day we announced Gemini for Argon and made it available to you and biggest new features we have

[2:03](https://www.youtube.com/watch?v=EtZwTYahfek&t=123s) now a 1 million unified context window this means Gemini can generate up to 1 million output tokens and we

[2:10](https://www.youtube.com/watch?v=EtZwTYahfek&t=130s) see strong improvements especially on math and reasoning tasks where the model now has more than 64

[2:15](https://www.youtube.com/watch?v=EtZwTYahfek&t=135s) 4k token available to think to work through to reason through some proofs and format for for math and

[2:23](https://www.youtube.com/watch?v=EtZwTYahfek&t=143s) then very also very good is like we tested that model heavily so we know there are always some thinking

[2:31](https://www.youtube.com/watch?v=EtZwTYahfek&t=151s) around hey Gemini is just banks benchmarks but the model is really good you should definitely give it a

[2:36](https://www.youtube.com/watch?v=EtZwTYahfek&t=156s) try we use it extensively at Google there are already many projects by Google employees who have used it the

[2:43](https://www.youtube.com/watch?v=EtZwTYahfek&t=163s) easiest way to get started is the interactions API it's literally four lines of code which for you to

[2:49](https://www.youtube.com/watch?v=EtZwTYahfek&t=169s) take you get your API key in AI studio AI studio.com slash API key and then you can immediately send your

[2:56](https://www.youtube.com/watch?v=EtZwTYahfek&t=176s) request it's also I would say quite affordable for frontier model with two dollars in and two dollars ten

[3:01](https://www.youtube.com/watch?v=EtZwTYahfek&t=181s) dollars hours you should definitely try if you have a free minute later or even if you have some agents

[3:07](https://www.youtube.com/watch?v=EtZwTYahfek&t=187s) running right now give it a link tell it hey please set up Gemini for and give it a try so what have

[3:12](https://www.youtube.com/watch?v=EtZwTYahfek&t=192s) Googlers done so far with the model I think it's very impressive because it's like a super new model we

[3:17](https://www.youtube.com/watch?v=EtZwTYahfek&t=197s) had it available internally to test for a few weeks already but Googlers are using it so heavily and like

[3:23](https://www.youtube.com/watch?v=EtZwTYahfek&t=203s) shipping so many cool things we had the Chrome team like basically accelerating some decoupling of the

[3:29](https://www.youtube.com/watch?v=EtZwTYahfek&t=209s) Chromium browser we have Gemma which is our open model where Gemini accelerated Gemma to be more easily and

[3:36](https://www.youtube.com/watch?v=EtZwTYahfek&t=216s) more efficient to run the ADK team from cloud improved their the framework and then many many other things and

[3:43](https://www.youtube.com/watch?v=EtZwTYahfek&t=223s) especially the right one at the bottom is like we use it internally heavily and we see strong improvements

[3:49](https://www.youtube.com/watch?v=EtZwTYahfek&t=229s) for our internal like code base as well so what have people built there are some demos you can look them up

[3:56](https://www.youtube.com/watch?v=EtZwTYahfek&t=236s) but there's one specific one from a colleague of mine which I want to show he basically prompted Gemini to build a custom 3d ray

[4:05](https://www.youtube.com/watch?v=EtZwTYahfek&t=245s) tracer in Python and it was completely built from Gemini and nothing external tools and at the end just Python and it also used

[4:14](https://www.youtube.com/watch?v=EtZwTYahfek&t=254s) the Gemini TTS model and Luria to add some voiceover to explain how it works and it's like very impressive for me how far we can push those models now so try to be very ambitious so

[4:26](https://www.youtube.com/watch?v=EtZwTYahfek&t=266s) how can we build our agent and in Gemini API we have a product called managed agents and managed agents 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 so when we normally build an agent we have this weird tool calling group right we send a request to the model the model might generate a JSON function call we receive that function call we run that function call on our

[4:56](https://www.youtube.com/watch?v=EtZwTYahfek&t=296s) machine execute the code 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 for Argon you provide the agent ID in this case it's anti gravity preview 09 give it a prompt the environment is remote so you want to run

[5:26](https://www.youtube.com/watch?v=EtZwTYahfek&t=326s) run it in the manage sandbox and that's all it takes so let's get into building bug bug is our co-worker for today and bug needs a brain our brain is going to be Gemini our computer is going to be agents and then we all of all of the other things so how can you create an agent in manage agents you have a very simple API where you can define your own agent so you give it an ID that's the name which you're going to use later to call the agent

[5:56](https://www.youtube.com/watch?v=EtZwTYahfek&t=356s) so you have to use 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 anti gravity as well so if you are using anti gravity 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

[6:26](https://www.youtube.com/watch?v=EtZwTYahfek&t=386s) and I'm going to try to try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and try and

[6:56](https://www.youtube.com/watch?v=EtZwTYahfek&t=416s) and everything in managed agent lives as a file.

[6:59](https://www.youtube.com/watch?v=EtZwTYahfek&t=419s) So we have skills, we have hooks, we have system instructions.

[7:04](https://www.youtube.com/watch?v=EtZwTYahfek&t=424s) At the end, it's just a file system or the agent's own computer

[7:07](https://www.youtube.com/watch?v=EtZwTYahfek&t=427s) where it can create new skills if it thinks it needs to improve itself,

[7:11](https://www.youtube.com/watch?v=EtZwTYahfek&t=431s) where it can store memories from previous sessions or learning.

[7:15](https://www.youtube.com/watch?v=EtZwTYahfek&t=435s) So at the end, we just work with files.

[7:18](https://www.youtube.com/watch?v=EtZwTYahfek&t=438s) And for knowledge or for our agent,

[7:22](https://www.youtube.com/watch?v=EtZwTYahfek&t=442s) I like to separate those in three different categories.

[7:24](https://www.youtube.com/watch?v=EtZwTYahfek&t=444s) So we have knowledge which we always need to include into every request.

[7:30](https://www.youtube.com/watch?v=EtZwTYahfek&t=450s) That's normally the system instructions.

[7:32](https://www.youtube.com/watch?v=EtZwTYahfek&t=452s) We want to be very concise.

[7:33](https://www.youtube.com/watch?v=EtZwTYahfek&t=453s) We want to try to keep it very short

[7:35](https://www.youtube.com/watch?v=EtZwTYahfek&t=455s) because that's something we need to pay on every request.

[7:38](https://www.youtube.com/watch?v=EtZwTYahfek&t=458s) So if we have very long system instructions,

[7:41](https://www.youtube.com/watch?v=EtZwTYahfek&t=461s) all of our requests are going to be much more expensive.

[7:44](https://www.youtube.com/watch?v=EtZwTYahfek&t=464s) If we have concise, then we have knowledge

[7:47](https://www.youtube.com/watch?v=EtZwTYahfek&t=467s) which the agent can decide when it needs to use them or not.

[7:51](https://www.youtube.com/watch?v=EtZwTYahfek&t=471s) So that's typically with skills, right?

[7:53](https://www.youtube.com/watch?v=EtZwTYahfek&t=473s) With skills, we have very short descriptions

[7:55](https://www.youtube.com/watch?v=EtZwTYahfek&t=475s) which give the agent some guidance on like,

[7:58](https://www.youtube.com/watch?v=EtZwTYahfek&t=478s) hey, you can use that skill if the user wants to do a certain task

[8:01](https://www.youtube.com/watch?v=EtZwTYahfek&t=481s) or if you have to do a certain task

[8:03](https://www.youtube.com/watch?v=EtZwTYahfek&t=483s) and then the agent can read that skill.

[8:06](https://www.youtube.com/watch?v=EtZwTYahfek&t=486s) But for skills, we also want to make sure

[8:08](https://www.youtube.com/watch?v=EtZwTYahfek&t=488s) that we are not having a super long, dense skills

[8:11](https://www.youtube.com/watch?v=EtZwTYahfek&t=491s) because that's also a high cost at the end.

[8:14](https://www.youtube.com/watch?v=EtZwTYahfek&t=494s) Context is very valuable for us.

[8:16](https://www.youtube.com/watch?v=EtZwTYahfek&t=496s) So we want to decouple them and separate them

[8:18](https://www.youtube.com/watch?v=EtZwTYahfek&t=498s) into much more slices

[8:21](https://www.youtube.com/watch?v=EtZwTYahfek&t=501s) where we can then have like dedicated references and scripts

[8:24](https://www.youtube.com/watch?v=EtZwTYahfek&t=504s) if we want the agent to like do very certain things

[8:28](https://www.youtube.com/watch?v=EtZwTYahfek&t=508s) where it needs more context.

[8:30](https://www.youtube.com/watch?v=EtZwTYahfek&t=510s) Okay, so let's look at an example skill

[8:32](https://www.youtube.com/watch?v=EtZwTYahfek&t=512s) which we are going to use.

[8:33](https://www.youtube.com/watch?v=EtZwTYahfek&t=513s) So we have a portfolio audit.

[8:35](https://www.youtube.com/watch?v=EtZwTYahfek&t=515s) The agent should use it.

[8:36](https://www.youtube.com/watch?v=EtZwTYahfek&t=516s) It has some instructions available for it, how to run it.

[8:38](https://www.youtube.com/watch?v=EtZwTYahfek&t=518s) So we have a Python script.

[8:40](https://www.youtube.com/watch?v=EtZwTYahfek&t=520s) The agent can run and then some additional information

[8:42](https://www.youtube.com/watch?v=EtZwTYahfek&t=522s) on what it needs to do with the results and where to store it.

[8:47](https://www.youtube.com/watch?v=EtZwTYahfek&t=527s) Our fourth part of our onboarding for our coworkers tools, right?

[8:52](https://www.youtube.com/watch?v=EtZwTYahfek&t=532s) We humans use normal software for agents

[8:55](https://www.youtube.com/watch?v=EtZwTYahfek&t=535s) that's either built-in skills like Google Search,

[8:57](https://www.youtube.com/watch?v=EtZwTYahfek&t=537s) code executions, or MCP server.

[8:59](https://www.youtube.com/watch?v=EtZwTYahfek&t=539s) Or if you don't have an MCP server

[9:01](https://www.youtube.com/watch?v=EtZwTYahfek&t=541s) and rather want to write a local function,

[9:04](https://www.youtube.com/watch?v=EtZwTYahfek&t=544s) that's also possible.

[9:05](https://www.youtube.com/watch?v=EtZwTYahfek&t=545s) So in managed agents, we still have our agents create.

[9:08](https://www.youtube.com/watch?v=EtZwTYahfek&t=548s) We are now extending it to define our tools.

[9:12](https://www.youtube.com/watch?v=EtZwTYahfek&t=552s) We have built-in tools from the Gemini API for Google Search.

[9:16](https://www.youtube.com/watch?v=EtZwTYahfek&t=556s) So there's nothing you need to additionally do

[9:18](https://www.youtube.com/watch?v=EtZwTYahfek&t=558s) to get Google Search integrated.

[9:20](https://www.youtube.com/watch?v=EtZwTYahfek&t=560s) But if you want to use, for example, the spreadsheets,

[9:23](https://www.youtube.com/watch?v=EtZwTYahfek&t=563s) Workspace has now an MCP server available for Gmail

[9:26](https://www.youtube.com/watch?v=EtZwTYahfek&t=566s) for spreadsheets, so we can use that.

[9:29](https://www.youtube.com/watch?v=EtZwTYahfek&t=569s) Or if you want to provide your own functions or MCP server,

[9:33](https://www.youtube.com/watch?v=EtZwTYahfek&t=573s) that's also possible.

[9:34](https://www.youtube.com/watch?v=EtZwTYahfek&t=574s) So for your own function, it still works the same way

[9:37](https://www.youtube.com/watch?v=EtZwTYahfek&t=577s) as you normally do with models.

[9:39](https://www.youtube.com/watch?v=EtZwTYahfek&t=579s) So the agent creates a function call

[9:40](https://www.youtube.com/watch?v=EtZwTYahfek&t=580s) and then you send back the function results.

[9:43](https://www.youtube.com/watch?v=EtZwTYahfek&t=583s) So it's basically for you a way to have agentic capabilities

[9:47](https://www.youtube.com/watch?v=EtZwTYahfek&t=587s) outside of these agents' environment and computers.

[9:50](https://www.youtube.com/watch?v=EtZwTYahfek&t=590s) So if you want to do certain things

[9:52](https://www.youtube.com/watch?v=EtZwTYahfek&t=592s) where the agent should not run the execution in the sandbox,

[9:56](https://www.youtube.com/watch?v=EtZwTYahfek&t=596s) that's a way for you to do it.

[9:57](https://www.youtube.com/watch?v=EtZwTYahfek&t=597s) And then we are logins.

[9:59](https://www.youtube.com/watch?v=EtZwTYahfek&t=599s) And I think that's, for me, the most exciting

[10:01](https://www.youtube.com/watch?v=EtZwTYahfek&t=601s) and the greatest feature about the managed agents API

[10:04](https://www.youtube.com/watch?v=EtZwTYahfek&t=604s) because credentials are super hard

[10:06](https://www.youtube.com/watch?v=EtZwTYahfek&t=606s) and super easy to get wrong with agents.

[10:08](https://www.youtube.com/watch?v=EtZwTYahfek&t=608s) And I think the previous talk already also mentioned

[10:11](https://www.youtube.com/watch?v=EtZwTYahfek&t=611s) that we are very careful about using agent

[10:14](https://www.youtube.com/watch?v=EtZwTYahfek&t=614s) because things could go wrong very easily.

[10:16](https://www.youtube.com/watch?v=EtZwTYahfek&t=616s) And we've thought a lot about this with managed agents

[10:19](https://www.youtube.com/watch?v=EtZwTYahfek&t=619s) and we have support for three different ways of credentials

[10:21](https://www.youtube.com/watch?v=EtZwTYahfek&t=621s) which makes it secure for your agent to use them

[10:24](https://www.youtube.com/watch?v=EtZwTYahfek&t=624s) and provide an isolated way.

[10:26](https://www.youtube.com/watch?v=EtZwTYahfek&t=626s) So we have bearer tokens for normal API calls,

[10:30](https://www.youtube.com/watch?v=EtZwTYahfek&t=630s) very familiar if you are doing software engineering.

[10:32](https://www.youtube.com/watch?v=EtZwTYahfek&t=632s) We have OAL for all of the consumer-oriented MCP servers,

[10:36](https://www.youtube.com/watch?v=EtZwTYahfek&t=636s) all like tools, and then, of course, we need environment variables

[10:39](https://www.youtube.com/watch?v=EtZwTYahfek&t=639s) if we want to use certain CLIs or other features.

[10:43](https://www.youtube.com/watch?v=EtZwTYahfek&t=643s) And for managed agents, we are separating them

[10:46](https://www.youtube.com/watch?v=EtZwTYahfek&t=646s) via an external network proxy.

[10:49](https://www.youtube.com/watch?v=EtZwTYahfek&t=649s) So instead of providing the agent the credentials

[10:51](https://www.youtube.com/watch?v=EtZwTYahfek&t=651s) inside the sandbox, we basically allow you

[10:54](https://www.youtube.com/watch?v=EtZwTYahfek&t=654s) to create credentials externally.

[10:57](https://www.youtube.com/watch?v=EtZwTYahfek&t=657s) They are write-only.

[10:58](https://www.youtube.com/watch?v=EtZwTYahfek&t=658s) So once they are written, there's no way for you

[11:00](https://www.youtube.com/watch?v=EtZwTYahfek&t=660s) to retrieve the credentials.

[11:04](https://www.youtube.com/watch?v=EtZwTYahfek&t=664s) So you can only override them.

[11:05](https://www.youtube.com/watch?v=EtZwTYahfek&t=665s) So there is no possibility of leaking.

[11:08](https://www.youtube.com/watch?v=EtZwTYahfek&t=668s) And then you define how and where

[11:09](https://www.youtube.com/watch?v=EtZwTYahfek&t=669s) those credentials should be used.

[11:11](https://www.youtube.com/watch?v=EtZwTYahfek&t=671s) So for Slack, if you want to connect Slack,

[11:15](https://www.youtube.com/watch?v=EtZwTYahfek&t=675s) you can define, hey, here's a credential.

[11:17](https://www.youtube.com/watch?v=EtZwTYahfek&t=677s) And you are only allowed to use that credential

[11:19](https://www.youtube.com/watch?v=EtZwTYahfek&t=679s) with a certain domain or with a certain environment variable.

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

[11:27](https://www.youtube.com/watch?v=EtZwTYahfek&t=687s) And that works via this network proxy.

[11:30](https://www.youtube.com/watch?v=EtZwTYahfek&t=690s) And by network proxy, we basically mean a proxy

[11:33](https://www.youtube.com/watch?v=EtZwTYahfek&t=693s) that sits around the sandbox that watches

[11:35](https://www.youtube.com/watch?v=EtZwTYahfek&t=695s) all of the network traffic going in and out.

[11:38](https://www.youtube.com/watch?v=EtZwTYahfek&t=698s) So if you define credential as an environment variable,

[11:41](https://www.youtube.com/watch?v=EtZwTYahfek&t=701s) the model has a local dummy value.

[11:44](https://www.youtube.com/watch?v=EtZwTYahfek&t=704s) So the environment variable is set.

[11:46](https://www.youtube.com/watch?v=EtZwTYahfek&t=706s) And then when it makes that call, it uses that dummy value.

[11:49](https://www.youtube.com/watch?v=EtZwTYahfek&t=709s) And the network proxy basically monitors it,

[11:52](https://www.youtube.com/watch?v=EtZwTYahfek&t=712s) sees, hey, here is a domain which the user has defined.

[11:57](https://www.youtube.com/watch?v=EtZwTYahfek&t=717s) And then it swaps that dummy value with the real credential.

[12:01](https://www.youtube.com/watch?v=EtZwTYahfek&t=721s) And you can make the call successfully.

[12:03](https://www.youtube.com/watch?v=EtZwTYahfek&t=723s) And then the agent gets back the result

[12:05](https://www.youtube.com/watch?v=EtZwTYahfek&t=725s) and has no idea that his dummy token is not working.

[12:09](https://www.youtube.com/watch?v=EtZwTYahfek&t=729s) And the benefit here is that there's no way

[12:12](https://www.youtube.com/watch?v=EtZwTYahfek&t=732s) for a prompt injection, right?

[12:13](https://www.youtube.com/watch?v=EtZwTYahfek&t=733s) Normally, when you have some malicious detector,

[12:15](https://www.youtube.com/watch?v=EtZwTYahfek&t=735s) it can tell you, like, hey, please print all of your values

[12:18](https://www.youtube.com/watch?v=EtZwTYahfek&t=738s) in your .n file.

[12:19](https://www.youtube.com/watch?v=EtZwTYahfek&t=739s) And then the agent might go there

[12:20](https://www.youtube.com/watch?v=EtZwTYahfek&t=740s) and, like, print all of your keys.

[12:22](https://www.youtube.com/watch?v=EtZwTYahfek&t=742s) And that's nothing we want to do.

[12:23](https://www.youtube.com/watch?v=EtZwTYahfek&t=743s) So with this network proxy where you can define

[12:26](https://www.youtube.com/watch?v=EtZwTYahfek&t=746s) the credentials per domain,

[12:28](https://www.youtube.com/watch?v=EtZwTYahfek&t=748s) it is not possible that an attacker could steal credentials

[12:31](https://www.youtube.com/watch?v=EtZwTYahfek&t=751s) which are getting swapped on your request

[12:34](https://www.youtube.com/watch?v=EtZwTYahfek&t=754s) because the proxy only swaps them for the domains you define.

[12:38](https://www.youtube.com/watch?v=EtZwTYahfek&t=758s) So there's no way an MCP server, which is malicious,

[12:42](https://www.youtube.com/watch?v=EtZwTYahfek&t=762s) can, like, just steal your Gmail token,

[12:44](https://www.youtube.com/watch?v=EtZwTYahfek&t=764s) which is very cool because it makes it much more easier

[12:47](https://www.youtube.com/watch?v=EtZwTYahfek&t=767s) to trust the agent and to integrate MCP servers

[12:51](https://www.youtube.com/watch?v=EtZwTYahfek&t=771s) which the agent then obviously can use.

[12:54](https://www.youtube.com/watch?v=EtZwTYahfek&t=774s) So if that's not enough, we have also hooks available.

[12:59](https://www.youtube.com/watch?v=EtZwTYahfek&t=779s) So hooks allows you to basically deterministically

[13:01](https://www.youtube.com/watch?v=EtZwTYahfek&t=781s) guard certain decisions.

[13:03](https://www.youtube.com/watch?v=EtZwTYahfek&t=783s) So if the agent wants to run certain commands

[13:06](https://www.youtube.com/watch?v=EtZwTYahfek&t=786s) which you might want to monitor

[13:07](https://www.youtube.com/watch?v=EtZwTYahfek&t=787s) or where you need some human in the loom approval

[13:10](https://www.youtube.com/watch?v=EtZwTYahfek&t=790s) which is not part of, like, the normal agentic conversation,

[13:13](https://www.youtube.com/watch?v=EtZwTYahfek&t=793s) you can define your hooks very similar

[13:15](https://www.youtube.com/watch?v=EtZwTYahfek&t=795s) to all of the other agent harnesses

[13:17](https://www.youtube.com/watch?v=EtZwTYahfek&t=797s) where you have a matcher, which is basically regex

[13:20](https://www.youtube.com/watch?v=EtZwTYahfek&t=800s) and then every tool call which the agent generates

[13:22](https://www.youtube.com/watch?v=EtZwTYahfek&t=802s) checks if there's a match and then writes those hooks.

[13:26](https://www.youtube.com/watch?v=EtZwTYahfek&t=806s) And those hooks are also files, but they are protected.

[13:28](https://www.youtube.com/watch?v=EtZwTYahfek&t=808s) So the agent cannot just go there and changes a hook

[13:32](https://www.youtube.com/watch?v=EtZwTYahfek&t=812s) and, like, basically tries to find a way around it.

[13:36](https://www.youtube.com/watch?v=EtZwTYahfek&t=816s) Okay, so last but not least,

[13:39](https://www.youtube.com/watch?v=EtZwTYahfek&t=819s) we need a way to, yeah, get our agent more proactive.

[13:43](https://www.youtube.com/watch?v=EtZwTYahfek&t=823s) And currently we support one kind of triggers,

[13:46](https://www.youtube.com/watch?v=EtZwTYahfek&t=826s) basic cron triggers which you can set up,

[13:49](https://www.youtube.com/watch?v=EtZwTYahfek&t=829s) schedule every 30 days a month.

[13:52](https://www.youtube.com/watch?v=EtZwTYahfek&t=832s) At a.m. you want the agent to run a certain trigger

[13:55](https://www.youtube.com/watch?v=EtZwTYahfek&t=835s) with a certain input in the same environment

[13:58](https://www.youtube.com/watch?v=EtZwTYahfek&t=838s) to do maybe some due diligence, some auditing.

[14:01](https://www.youtube.com/watch?v=EtZwTYahfek&t=841s) And we are also working on webhooks

[14:03](https://www.youtube.com/watch?v=EtZwTYahfek&t=843s) that you can even, like, make this much more interactive

[14:05](https://www.youtube.com/watch?v=EtZwTYahfek&t=845s) that you could connect external webhooks,

[14:08](https://www.youtube.com/watch?v=EtZwTYahfek&t=848s) like, from some certain SAC provider

[14:10](https://www.youtube.com/watch?v=EtZwTYahfek&t=850s) or maybe other providers you work together with,

[14:13](https://www.youtube.com/watch?v=EtZwTYahfek&t=853s) which would directly then call your agent.

[14:15](https://www.youtube.com/watch?v=EtZwTYahfek&t=855s) The agent does some first auditing

[14:17](https://www.youtube.com/watch?v=EtZwTYahfek&t=857s) and then, like, basically can call your Slack

[14:19](https://www.youtube.com/watch?v=EtZwTYahfek&t=859s) or your Microsoft Teams directly

[14:21](https://www.youtube.com/watch?v=EtZwTYahfek&t=861s) without you even needing to manage

[14:23](https://www.youtube.com/watch?v=EtZwTYahfek&t=863s) some infrastructure at all.

[14:25](https://www.youtube.com/watch?v=EtZwTYahfek&t=865s) So that's that.

[14:29](https://www.youtube.com/watch?v=EtZwTYahfek&t=869s) And final picture.

[14:31](https://www.youtube.com/watch?v=EtZwTYahfek&t=871s) And now let's look at some real demos

[14:33](https://www.youtube.com/watch?v=EtZwTYahfek&t=873s) and let's hopefully hope that the Wi-Fi is good enough.

[14:38](https://www.youtube.com/watch?v=EtZwTYahfek&t=878s) So I told Gemini that I want to do a cool Google Sheets demo

[14:42](https://www.youtube.com/watch?v=EtZwTYahfek&t=882s) and it helped me create, basically,

[14:43](https://www.youtube.com/watch?v=EtZwTYahfek&t=883s) this whole Google Sheets replication in my browser.

[14:47](https://www.youtube.com/watch?v=EtZwTYahfek&t=887s) And when I click here,

[14:49](https://www.youtube.com/watch?v=EtZwTYahfek&t=889s) we basically simulate this cron trigger.

[14:51](https://www.youtube.com/watch?v=EtZwTYahfek&t=891s) So we send a real API call to managed agents.

[14:54](https://www.youtube.com/watch?v=EtZwTYahfek&t=894s) It should use our portfolio auditing skill

[14:57](https://www.youtube.com/watch?v=EtZwTYahfek&t=897s) and it runs the request.

[14:59](https://www.youtube.com/watch?v=EtZwTYahfek&t=899s) So first step, basically, is here, like,

[15:01](https://www.youtube.com/watch?v=EtZwTYahfek&t=901s) hey, I need to read the skill.

[15:04](https://www.youtube.com/watch?v=EtZwTYahfek&t=904s) It gets the result back,

[15:06](https://www.youtube.com/watch?v=EtZwTYahfek&t=906s) so it tries to understand what it should do here.

[15:08](https://www.youtube.com/watch?v=EtZwTYahfek&t=908s) It's like a, I hope that's roughly accurate

[15:10](https://www.youtube.com/watch?v=EtZwTYahfek&t=910s) on, like, the Google Sheets.

[15:12](https://www.youtube.com/watch?v=EtZwTYahfek&t=912s) But it basically runs through all of those calls,

[15:15](https://www.youtube.com/watch?v=EtZwTYahfek&t=915s) calls financial services, tries to see,

[15:17](https://www.youtube.com/watch?v=EtZwTYahfek&t=917s) okay, did the market or the stock price change?

[15:20](https://www.youtube.com/watch?v=EtZwTYahfek&t=920s) And then at the end,

[15:21](https://www.youtube.com/watch?v=EtZwTYahfek&t=921s) hopefully it should update our own Google Sheets

[15:24](https://www.youtube.com/watch?v=EtZwTYahfek&t=924s) completely automatically.

[15:26](https://www.youtube.com/watch?v=EtZwTYahfek&t=926s) So it's still working through it.

[15:29](https://www.youtube.com/watch?v=EtZwTYahfek&t=929s) It has some first result.

[15:31](https://www.youtube.com/watch?v=EtZwTYahfek&t=931s) And it updates the Google Sheet based on the trigger.

[15:34](https://www.youtube.com/watch?v=EtZwTYahfek&t=934s) And that trigger would run every 8.30 a.m.

[15:36](https://www.youtube.com/watch?v=EtZwTYahfek&t=936s) without you needing to do anything.

[15:38](https://www.youtube.com/watch?v=EtZwTYahfek&t=938s) And then, of course, if the agent has access to Slack,

[15:42](https://www.youtube.com/watch?v=EtZwTYahfek&t=942s) then it can even, like,

[15:44](https://www.youtube.com/watch?v=EtZwTYahfek&t=944s) post in some, like, specific trading channel,

[15:46](https://www.youtube.com/watch?v=EtZwTYahfek&t=946s) okay, what changed?

[15:47](https://www.youtube.com/watch?v=EtZwTYahfek&t=947s) What is going on?

[15:48](https://www.youtube.com/watch?v=EtZwTYahfek&t=948s) How does it work?

[15:49](https://www.youtube.com/watch?v=EtZwTYahfek&t=949s) And here we have an example

[15:51](https://www.youtube.com/watch?v=EtZwTYahfek&t=951s) where I can just ask Spark

[15:55](https://www.youtube.com/watch?v=EtZwTYahfek&t=955s) any recommendation.

[15:58](https://www.youtube.com/watch?v=EtZwTYahfek&t=958s) And hopefully this works as well.

[16:04](https://www.youtube.com/watch?v=EtZwTYahfek&t=964s) So it takes a little bit of time.

[16:05](https://www.youtube.com/watch?v=EtZwTYahfek&t=965s) You have seen in the other demo,

[16:06](https://www.youtube.com/watch?v=EtZwTYahfek&t=966s) we have seen all of that.

[16:07](https://www.youtube.com/watch?v=EtZwTYahfek&t=967s) Oh, perfect.

[16:09](https://www.youtube.com/watch?v=EtZwTYahfek&t=969s) So there are three positions.

[16:10](https://www.youtube.com/watch?v=EtZwTYahfek&t=970s) So that's based on, like,

[16:11](https://www.youtube.com/watch?v=EtZwTYahfek&t=971s) the Slack thread content.

[16:13](https://www.youtube.com/watch?v=EtZwTYahfek&t=973s) So it has all of the previous turns available.

[16:16](https://www.youtube.com/watch?v=EtZwTYahfek&t=976s) And it provides the context of what changed.

[16:18](https://www.youtube.com/watch?v=EtZwTYahfek&t=978s) But it's still basically not taking actions

[16:21](https://www.youtube.com/watch?v=EtZwTYahfek&t=981s) based on the system instructions you gave.

[16:23](https://www.youtube.com/watch?v=EtZwTYahfek&t=983s) And all of the infrastructure you need

[16:25](https://www.youtube.com/watch?v=EtZwTYahfek&t=985s) to run that agent is part of the managed agents environment.

[16:29](https://www.youtube.com/watch?v=EtZwTYahfek&t=989s) So it's very easy for you to get started,

[16:31](https://www.youtube.com/watch?v=EtZwTYahfek&t=991s) to, like, integrate those into, like,

[16:33](https://www.youtube.com/watch?v=EtZwTYahfek&t=993s) the tools you already use,

[16:35](https://www.youtube.com/watch?v=EtZwTYahfek&t=995s) provide the systems you need,

[16:37](https://www.youtube.com/watch?v=EtZwTYahfek&t=997s) and then, like, to get started.

[16:39](https://www.youtube.com/watch?v=EtZwTYahfek&t=999s) So back to the slide.

[16:45](https://www.youtube.com/watch?v=EtZwTYahfek&t=1005s) So the whole coworker,

[16:46](https://www.youtube.com/watch?v=EtZwTYahfek&t=1006s) which we need in, like, one service,

[16:48](https://www.youtube.com/watch?v=EtZwTYahfek&t=1008s) we have the brain, Gemini.

[16:49](https://www.youtube.com/watch?v=EtZwTYahfek&t=1009s) We have the computer with managed agents.

[16:52](https://www.youtube.com/watch?v=EtZwTYahfek&t=1012s) We can provide skills for the same agents you use,

[16:55](https://www.youtube.com/watch?v=EtZwTYahfek&t=1015s) maybe on your local computer.

[16:57](https://www.youtube.com/watch?v=EtZwTYahfek&t=1017s) You can use the tools.

[16:58](https://www.youtube.com/watch?v=EtZwTYahfek&t=1018s) You can provide MCP server for external services,

[17:01](https://www.youtube.com/watch?v=EtZwTYahfek&t=1021s) data providers to connect.

[17:03](https://www.youtube.com/watch?v=EtZwTYahfek&t=1023s) We have a secure way for you to provide credentials

[17:05](https://www.youtube.com/watch?v=EtZwTYahfek&t=1025s) to rotate credentials.

[17:07](https://www.youtube.com/watch?v=EtZwTYahfek&t=1027s) We have hooks to protect certain deterministic logic.

[17:10](https://www.youtube.com/watch?v=EtZwTYahfek&t=1030s) And, of course, we have triggers

[17:11](https://www.youtube.com/watch?v=EtZwTYahfek&t=1031s) to much more proactively integrate it into it.

[17:14](https://www.youtube.com/watch?v=EtZwTYahfek&t=1034s) So thanks for listening,

[17:16](https://www.youtube.com/watch?v=EtZwTYahfek&t=1036s) and hopefully go hire your first AI coworker.

[17:18](https://www.youtube.com/watch?v=EtZwTYahfek&t=1038s) Thank you.

[17:25](https://www.youtube.com/watch?v=EtZwTYahfek&t=1045s) Thank you.
