# Tethered: Our Agents Are Us — Shu Fang, Two Sigma

Shu Fang, Two Sigma

[Talk page](https://ai.engineer/talks/wCIYViPd4SU-tethered-our-agents-are-us) · [Video](https://www.youtube.com/watch?v=wCIYViPd4SU)

## Tethered: Our Agents Are Us

In a personal account of work completed the previous year, Shu Fang explains how Two Sigma ran remote cloud agents as employees themselves, then restored accountability with propagated provenance and constrained web access to an enterprise-controlled search path.

### Remote agents force an identity decision

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

Shu Fang opens with two pieces of context: Two Sigma is 25 years old and operates in a regulated industry, and his account reflects his own views rather than an official company endorsement. Even in that setting, he says, every employee gained access to a cloud agent running under the employee’s own identity. The work described began around June 2025 and had been completed during the year before this talk.

Fang calls these agents “tethered,” borrowing the doubles from the film *Us*. The metaphor captures the design problem: a double is useful while its behavior remains attached to its human, but dangerous when it can run loose without constraints or accountability.

The project started with a usability problem. Local coding agents were powerful but tied to a command line and a particular computer. The goal was to make remote agents reachable from mobile devices, Slack, and browsers—including by employees who would not be comfortable operating entirely inside a CLI. Moving execution into the cloud broadened access, but immediately raised the question: whose identity should the remote agent use?

### Why “Shu” plus “Shu agent” became the wrong boundary

[2:55](https://www.youtube.com/watch?v=wCIYViPd4SU&t=175s)

The conventional answer is to give each agent a separate machine identity associated with its human owner: one identity for Shu, another for Shu’s agent. That looks like clean separation until the two identities must do the same work against the same systems.

![Recording frame at 195 seconds](https://ai.engineer/api/talk-essay-media/e849f699a9434b7588b2364011d0fff196da7ec759088933cf116bc32b30a0eb)

Recording frame at 195 seconds

The separate identity creates several parallel maintenance problems:

- **Permission drift:** Every change to the human’s access must be reflected in the agent account.
- **Duplicate licensing:** Software licensed per identity may require a second license.
- **Shared-data incompatibility:** Some systems do not support two identities operating on the same underlying user data, including email and other workspace data.
- **A new policy boundary:** Systems may reject the machine identity outright, while security teams must repeatedly decide what belongs on each side of the human–agent boundary.

Running the agent as the user removes those synchronization problems. The agent receives the capabilities and access the employee already has instead of depending on a parallel account that must continually imitate them. This simplifies authorization, but it also deliberately collapses the identity-level distinction between human and agent. The rest of the architecture must restore that distinction somewhere else.

The necessary infrastructure already existed for ordinary automation. Two Sigma had Kubernetes clusters across regions, with a namespace for each person in every region. Automated jobs, code containers, and research notebooks already needed remote compute that could act as the user instead of being confined to a laptop.

How does a remote agent start with its user’s identity? A trigger asks a controller to create compute in the employee’s namespace. A sidecar in the resulting pod obtains identity material from a separate identity service and mounts it for the working container. The container therefore executes remotely while retaining the employee’s established identity.

How a remote agent starts as its user
Existing per-user Kubernetes infrastructure supplies compute placement and a user-specific runtime boundary; a separate identity service lets the workload act with the employee’s identity.
- Remote trigger — A request arrives from an interface and asks for compute.
- Controller — Creates compute resources for the request.
- User namespace — A namespace already exists for each user in each region.
- Identity service — Supplies the user identity for the workload.
- Identity sidecar — Retrieves and mounts identity material for the pod.
- Agent container — Runs remotely with the employee’s capabilities and access.
- Remote trigger → Controller (requests compute)
- Controller → User namespace (starts pod)
- Identity service → Identity sidecar (provides identity)
- Identity sidecar → Agent container (mounts identity)
- User namespace → Agent container (hosts workload)

### The identity shortcut creates two serious dangers

[5:07](https://www.youtube.com/watch?v=wCIYViPd4SU&t=307s)

The first danger is internal attribution. Because the person and agent authenticate as the same actor, ordinary identity logs cannot answer whether a human clicked, typed, or called something directly, or whether an agent initiated the action. That distinction matters when a company needs to audit an action, block agent-specific behavior, or reconstruct what happened.

![Recording frame at 383 seconds](https://ai.engineer/api/talk-essay-media/baacb52ae302ddfb63cdf9dca86df09dd4215e386a85b08fafe8c4b943e72bad)

Recording frame at 383 seconds

The second danger is web access. Models contain point-in-time knowledge, so useful agents often need search and fetch tools for current information. Unrestricted internet access, however, creates several risks at once:

- **Exfiltration:** Sensitive information or intellectual property can leave the company.
- **Hostile input:** Untrusted pages can return prompt injections, malware, or exploit content.
- **Licensing exposure:** The agent may retrieve and use material without appropriate rights.

Fang frames the design as a finance problem: preserve the return from agents acting with full user capabilities while reducing the associated risk. That yields two concrete controls to build—provenance that separates human and agent activity, and a constrained route for web access.

### A propagated header records more than the actor

[7:54](https://www.youtube.com/watch?v=wCIYViPd4SU&t=474s)

Two Sigma’s implementation restores attribution with a header propagated through agent activity much like a distributed trace ID. Agent-controlled HTTP clients, MCP connections, skills, and harness code populate the header and continue carrying it through subsequent calls. Deterministic infrastructure surrounding the model preserves the metadata even though the model’s decisions are nondeterministic.

How does that marker preserve the origin of a multistep result? Consider a remote request that enters through Slack and causes an agent to call several internal services. The authenticated actor remains the employee throughout. At each hop, the agent marker joins the internal span: the first call records that an agent initiated the work, downstream calls inherit the marker, and the final result can be traced back through the chain. The observable change is larger than a label saying “an agent did this”; the record now contains the route that led to the outcome.

A separate “Shu agent” account would identify the initial machine actor, but identity alone would not necessarily preserve the complete causal chain through later systems. Propagated metadata supplies provenance across the sequence while the underlying authorization still belongs to Shu. Actor identity and execution origin become separate, complementary facts.

How agent provenance survives a multi-service call chain
The employee identity authorizes each call, while agent metadata propagates through the trace so the initiating path remains reconstructable.
- Employee request — The user initiates work through a remote interface.
- Agent runtime — Populates the provenance marker while acting as the employee.
- First service — Receives the user identity and agent marker.
- Downstream service — Carries the marker into an internal span.
- Result with provenance — The action chain can be reconstructed back to its origin.
- Employee request → Agent runtime (delegates work)
- Agent runtime → First service (identity + marker)
- First service → Downstream service (propagates marker)
- Downstream service → Result with provenance (records causal chain)

### Replace open egress with one controlled web path

[9:56](https://www.youtube.com/watch?v=wCIYViPd4SU&t=596s)

For web access, Fang says the system used **Web Grounding for Enterprise**, described in the talk as access to Google’s web index from inside the company’s existing VPC and network controls. It mirrored the two capabilities agents needed—search and fetch—without letting the agent contact arbitrary external sites directly.

![Recording frame at 630 seconds](https://ai.engineer/api/talk-essay-media/79fedf2f24b439b114754577306694fe89466150c8b54fb2338163269bb01d2f)

Recording frame at 630 seconds

The tradeoff was freshness. Fang said that, the last time he checked, indexed data was available within roughly 24 hours and more frequently updated sites within roughly six hours. Those figures are explicitly time-bound observations from the described implementation, not permanent service guarantees. For the use cases under discussion, he considered the delay acceptable in exchange for removing direct external egress.

Providing the safer tool is insufficient if the original tools remain available. The harness therefore denied its native web-search and web-fetch tools, removing them from the agent’s usable tool suite. Requests that needed web information were redirected through supported MCP, CLI, client-code, or skill paths into the controlled index. This was a routing rule enforced outside the model, rather than an instruction asking the model to remember the preferred route.

What route remains after the native tools are denied? The agent has one permitted path to web-derived information and no native bypass. Search and fetch remain useful capabilities, but their network path changes from arbitrary internet egress to an indexed service operating inside the controlled boundary.

The controlled index also applied curation and other safety controls that Fang said reduced prompt-injection risk. It did not eliminate that risk: he explicitly allowed that curation could fail. Keeping retrieval internal primarily reduces exposure and gives the enterprise a controlled inspection point; it does not make hostile content inherently trustworthy.

In Fang’s assessment, these controls moved the risk–return position without removing the core capability. The index lagged the open web, but the provenance marker supplied more observability than identity alone, and web access no longer required unrestricted egress. His conclusion was that the risk fell much further than the expected value did.

Open web access versus the tethered route
Denying native tools closes the bypass; supported clients direct search and fetch through the enterprise-controlled index.
- Cloud agent — Runs as the employee and needs current information.
- Native search and fetch — Direct web tools are denied and removed from the available suite.
- Open internet — Direct access creates exfiltration and hostile-input exposure.
- Supported MCP, CLI, client, or skill — Routes requests through an approved interface.
- Enterprise web index — Provides search and fetch inside existing network controls.
- Controlled web result — Returns indexed information without arbitrary external egress.
- Cloud agent → Native search and fetch (tool denied)
- Native search and fetch → Open internet (no route)
- Cloud agent → Supported MCP, CLI, client, or skill (approved request)
- Supported MCP, CLI, client, or skill → Enterprise web index (search or fetch)
- Enterprise web index → Controlled web result (returns indexed content)

### What had shipped—and the boundaries that remained

[13:03](https://www.youtube.com/watch?v=wCIYViPd4SU&t=783s)

By Fang’s account, the prior year’s work produced a framework combining remote user-identity execution, non-CLI interfaces, provenance propagation, and controlled web access. Two Sigma also operated a managed fleet of remote agents for employees while preserving the more general ability for anyone at the firm to deploy an agent into their own namespace under their full identity.

![Recording frame at 853 seconds](https://ai.engineer/api/talk-essay-media/c352a865153db82aee84d78f6932bc419fc673310d63fe82bdb6e47f1979b9b6)

Recording frame at 853 seconds

The Q&A sharpens an important security distinction: the provenance header is not authentication. Someone could populate an agent marker themselves, but that would not let them become Shu. The system still verified the originating identity through its existing identity chain, then used the separate header to classify and trace agent involvement. For non-HTTP downstream work, the marker entered through an RPC boundary and became part of the internal span, much like a trace ID.

Fang also expected self-managed models to become attractive for a substantial share of enterprise inference. His reasons were operational: cost, provider deprecations, and performance changes when frontier labs released new models. He presented this as his personal direction of travel, not as a description of the deployed architecture.

Agent session data introduced another privacy boundary. Two Sigma tried to keep a user’s sessions localized rather than exposing them broadly across the firm, because work sessions could contain information privileged to that employee. Within that boundary, usage patterns could improve configuration and personalization based on what the person actually did, rather than only their position in an organizational hierarchy.

Provisioning was deliberately unremarkable: the necessary namespace infrastructure already existed for every user, so an employee could build an agent with existing frameworks and deploy it under their identity. Promotion was a separate decision. An individually useful agent did not become a team-wide or company-wide service merely because it could run; it went through the normal production questions around support, security, and operational ownership, like any other application.

## Key takeaways

- A separate per-user agent identity creates permission drift, duplicate licensing, incompatible access patterns, and a boundary that must be maintained indefinitely.
- Existing per-user Kubernetes namespaces can host remote agents under employee identities, with a sidecar obtaining and mounting identity material from a separate service.
- Authentication establishes who is acting; a propagated agent marker records whether an agent initiated the work and preserves provenance through downstream spans.
- Safe routing requires both an approved web source and denial of native search and fetch tools, so the model cannot bypass the controlled path.
- In the implementation Fang described, a controlled index reduced external-egress and prompt-injection exposure but traded away freshness and could not guarantee that hostile content would never pass curation.
- Personal agents can be self-service because infrastructure is pre-provisioned; broader deployment still requires ordinary production support and security review.

## Related talks

- [CIAM for AI: Authn/Authz for Agents — Michael Grinich, CEO of WorkOS](https://ai.engineer/talks/D4Dswf-__RM-ciam-ai-authn-authz-agents) — Extends the identity discussion with delegated access, signed identity chains, scoped capabilities, and human-linked auditability.
- [Privacy First Enterprise AI: Building AI Agents that Never Leave Your Security Boundary](https://ai.engineer/talks/_pBfv1rbLBU-privacy-first-enterprise-ai-building-ai-agents) — Explores the complementary pattern of operating enterprise agents inside existing identity, cloud, and security boundaries.
- [Security Firewall for Agents](https://ai.engineer/talks/MkRYPFIMCSA-security-firewall-agents) — Examines why independent network enforcement is still needed when agents have powerful credentials and can encounter prompt-injected content.

## Slides

### Tethered: Our Agents Are Us

Shu Fang of Two Sigma introduces Tethered: Our Agents Are Us.

[0:17](https://www.youtube.com/watch?v=wCIYViPd4SU&t=17s) [Title slide for Shu Fang’s Two Sigma talk, Tethered: Our Agents Are Us.](https://assets.ai.engineer/sites/aiecode2025/sha256/bd20142ad9014232f16b98fc38d907f48b6e565b839bd4bdf70062c472540018.webp)

2σ TWO SIGMA

Tethered: Our Agents Are Us

Shu Fang · Two Sigma · AIEWF2026

### Two Sigma: Quant Fund

Two Sigma combines many weak signals into one forecast and hedges volatility. Fang connects the firm’s name to σ for volatility and Σ for summation.

[0:22](https://www.youtube.com/watch?v=wCIYViPd4SU&t=22s) [Diagram shows many weak signals summed into one amplified forecast.](https://assets.ai.engineer/sites/aiecode2025/sha256/58cc5702311d751b055b9f35295cc73b34e5a4b7f99ae31bd47eb5f7feaa819f.webp)

Two Sigma: Quant Fund

2σ

Σ
sum

many weak signals
each: σ = volatility vs. benchmark

one amplified forecast
sum the signals, hedge the σ

Company
2σ

### Important Legal Information

The presentation is for informational and educational purposes, not investment advice. The views are the author’s, and the use of third-party information or logos does not imply endorsement.

[0:51](https://www.youtube.com/watch?v=wCIYViPd4SU&t=51s) [Legal information covering educational use, investment advice, third-party data, and copyrights and trademarks.](https://assets.ai.engineer/sites/aiecode2025/sha256/e67e5273a4ef8cee2273ea285deee2106f39efe668f2d5e70247e00914212b38.webp)

Important Legal Information

This document is being distributed for informational and educational purposes only and is not an offer to sell or the solicitation of an offer to buy any securities or other instruments. The information contained herein is not intended to provide, and should not be relied upon for, investment advice. The views expressed herein are not necessarily the views of Two Sigma Investments, LP or any of its affiliates (collectively, “Two Sigma”). Such views reflect the assumptions of the author(s) of the document and are subject to change without notice. The document may employ data derived from third-party sources. No representation is made by Two Sigma as to the accuracy of such information and the use of such information in no way implies an endorsement of the source of such information or its validity.

Disclaimer

The copyrights and/or trademarks in some of the images, logos or other material used herein may be owned by entities other than Two Sigma. If so, such copyrights and/or trademarks are most likely owned by the entity that created the material and are used purely for identification and comment as fair use under international copyright and/or trademark laws. Use of such image, copyright or trademark does not imply any association with such organization (or endorsement of such organization) by Two Sigma, nor vice versa.

2σ
3

### Cloud agents run as their users

At 25-year-old Two Sigma, everyone has a cloud agent that runs as their own identity. Fang asks how the company got comfortable with that in a heavily regulated industry.

[1:16](https://www.youtube.com/watch?v=wCIYViPd4SU&t=76s) [Slide states that everyone runs a cloud agent as their own identity and asks how and why.](https://assets.ai.engineer/sites/aiecode2025/sha256/9e9a4f557084ad9a4238f5d4a3107338ed849b57f27c5e05a879e9b8cf27a6a7.webp)

25 YEARS OLD · ONE OF THE MOST REGULATED INDUSTRIES ON EARTH

Everyone here runs a cloud agent
as their own identity.

How did we get here? And why are we ok with it?

### The Tethered in Us

Fang uses Us as an analogy: a double cut loose causes chaos. The slide casts agents as doubles that should remain tethered to their users.

[1:42](https://www.youtube.com/watch?v=wCIYViPd4SU&t=102s) [Illustrations compare a double with an untethered double, relating the analogy to keeping agents tethered.](https://assets.ai.engineer/sites/aiecode2025/sha256/aa7b9a3c505e5e23c44d9073b6fb15d8d7875961c7fbace2d186bdb28ce79bb7.webp)

FIRST, A HORROR MOVIE

Us · Jordan Peele, 2019

everyone has a double — “the Tethered.”

THE DOUBLE
a copy of you, kept below

UNTETHERED
cut loose, golden scissors out — chaos

The danger isn’t the double. It’s a double cut loose.
So we keep ours tethered. Our agents are us.

### Agents outgrew the local terminal

The goal is to run agents in managed cloud compute, accessible from mobile, Slack, or a browser, with updates rolled out to every agent. That raises a question: what identity do they run as?

[2:08](https://www.youtube.com/watch?v=wCIYViPd4SU&t=128s) [Diagram contrasts a local Claude Code terminal with managed cloud agents accessible through mobile, Slack, and a browser.](https://assets.ai.engineer/sites/aiecode2025/sha256/ea26941db67295eb4dfdc5438f9f62008c06915920b853d3317f6c3dd907f67b.webp)

Agents outgrew the local terminal.

June 2025: Claude Code

CLI
$ claude

Powerful, but local.
one person, one machine

Goal: Agentic Assistant as a Service

Setup
Mobile
Slack
Browser

managed rollout
tools · models · fixes, to every agent

in the cloud
you connect to and run agents here
agent
agent
agent
managed, autoscaling compute

what does it run as?

6

### Separate agent identity collapses

A separate machine identity tied to the user can fall out of sync on permissions, require a second software seat, and face systems that block access or lack second-identity support.

[2:53](https://www.youtube.com/watch?v=wCIYViPd4SU&t=173s) [A user and separate agent identity are contrasted with problems including permission drift, extra seats, and restricted access.](https://assets.ai.engineer/sites/aiecode2025/sha256/23a474c43a5fecb1041623d652d0688208a8b3bb45b2a391109b9da25b527ac3.webp)

Separate agent identity collapses.

Conventional wisdom
shu
shu-agent

Where it breaks
Permissions drift out of sync
Two software seats, double cost
No second-identity support
Blocked from systems by default
Stuck at public-only access

Setup

### Run the agent as the user, remotely

Fang proposes running the agent remotely under the same user identity, giving it the user’s access to email, development tools and office apps with one software seat.

[3:40](https://www.youtube.com/watch?v=wCIYViPd4SU&t=220s) [A user connects to a remote agent that accesses email, development tools, and office applications as the user.](https://assets.ai.engineer/sites/aiecode2025/sha256/a6f358ff44e6685b453a48c2b4ca1518db3e571904db71bf6c42789c52db68ed.webp)

So: run the agent as the user, remotely.

remote, run as you

shu → shu

email, calendar — as you
Jira, repos, wikis — as you
Workspace / Office — as you

one identity · one seat · works everywhere

Setup
8

### Existing infrastructure for user workloads

Two Sigma already ran jobs, code containers, and research notebooks in a namespace for each user in every region. Everything in the namespace runs as that user.

[3:58](https://www.youtube.com/watch?v=wCIYViPd4SU&t=238s) [A Kubernetes cluster diagram shows per-user namespaces containing automated jobs, code containers, and research notebooks.](https://assets.ai.engineer/sites/aiecode2025/sha256/165a440f1523229232f709d45b94df0082fda71f5fc25255367fb13368fb4bae.webp)

We already had the infra. You probably do too.

Architecture

Kubernetes cluster
us-east
us-central
on-prem
one cluster per region

namespace: shu
runs as you
automated jobs
code container
research notebook

namespace: alice
automated jobs
code container
research notebook

namespace: bob
automated jobs
code container
research notebook

A namespace per user, in every region. Everything in it runs as you.

9

### How a pod runs as the user

A trigger starts a pod, where an identity sidecar retrieves and mounts the user's identity from the Platform Identity Service. The workload then runs as that user.

[4:42](https://www.youtube.com/watch?v=wCIYViPd4SU&t=282s) [A trigger starts a pod whose identity sidecar obtains and mounts the user's identity for the workload.](https://assets.ai.engineer/sites/aiecode2025/sha256/102e68265f066d48d2c22ef5583de9faae3101e3eff2e36b66bb39bb220abab4.webp)

How a pod spins up as the user identity.

Platform Identity Service
your identity

trigger
spins up your pod

pod
namespace: shu

identity sidecar
grabs & mounts your identity

your workload
runs as you

A sidecar grabs your identity and mounts it. Your code just runs as you.

Architecture
10

### Danger 1: which one of us did that?

When an agent acts as you, a database deletion can appear under the same identity whether you or the agent did it. Distinguishing the two enables auditing, targeted blocking, and attribution.

[5:05](https://www.youtube.com/watch?v=wCIYViPd4SU&t=305s) [A database deletion example illustrates why logs must distinguish a user's actions from an agent's for auditing, blocking, and attribution.](https://assets.ai.engineer/sites/aiecode2025/sha256/623ff34f78797abc2cb8948c592618fe5af0fbdfa1e94a0b0aa8db1f77bba858.webp)

Danger 1: which one of us did that?

INTERNAL: ACTING AS YOU

you
?
your agent

actor=shu DELETE orders
2.4M rows, gone
you? or your agent in a loop?

production DB

It logs as you. We have to know which, to:

audit it
accountability

what to block
the agent, not you

trace the source
attribution

Threats
11

### Danger 2: web access

Web access is a two-way door: sensitive data can leave, while untrusted content flows back in. Risks include prompt injection, malware and vulnerabilities, and copyright or licensing exposure.

[5:51](https://www.youtube.com/watch?v=wCIYViPd4SU&t=351s) [Arrows between an agent and the internet show data exfiltration and incoming untrusted content, with prompt injection, licensed content, and malware as examples.](https://assets.ai.engineer/sites/aiecode2025/sha256/22ae2b2a0d12a1347acb6610411c538f569ae1a7875c9a2b9763c26c87e857e2.webp)

Danger 2: web access is critical, but terrifying.

EXTERNAL: A TWO-WAY DOOR

OUT: exfiltration, your data leaves
IN: untrusted content flows back

your agent
web access
the open internet

Threats
Prompt injection
poisoned pages hijack it

Licensed content
copyright & IP exposure

Malware & vulns
poisoned code & deps

12

### Tag Every Action, End to End

Each agent appends its identifier to a header that travels through the call chain. Hooks, skills, MCP and HTTP clients help ensure the tag is included in every call.

[7:52](https://www.youtube.com/watch?v=wCIYViPd4SU&t=472s) [A diagram shows each agent appending its identifier to a propagated attribution tag.](https://assets.ai.engineer/sites/aiecode2025/sha256/8822b22d25bf218545e7e8832515bc097b8a8874d3fd2e227b660910424f9b39.webp)

Tag every action, end to end.

Attribution

we control the call path
hooks
skills
MCP
HTTP clients
the tag is baked into every call

the tag appends at every agent
claude-code/version + research/version + batch-svc/version

your agent
runs as you

your other agent
runs as you

machine-account agent
a service account

the resultant tag that lands at prod
X-TS-LLM-Agent: claude-code/version research/version batch-svc/version

14

### Agent or Human, and Why

Shu remains the actor while a propagating tag records the agent chain. One trace ID connects that chain to the production database read; a separate agent identity would lose the human and chain context.

[8:56](https://www.youtube.com/watch?v=wCIYViPd4SU&t=536s) [A trace links a human, agents and an action; a comparison shows a propagating tag preserving the human and agent chain.](https://assets.ai.engineer/sites/aiecode2025/sha256/7ac40ea9af3c774973672cb0c7994067d05590c28df702d023a80cf82250f7aa.webp)

Now we know: agent or human, and why.

shu
who
→ claude-code
your agent
→ research
your other agent
→ batch-svc
machine account
→ read prod-db
what it did

one trace-id · replay the entire chain of actions

Attribution

a separate agent identity
actor = shu-agent
X-TS-LLM-Agent: (none)
✗ no human · no chain

a propagating tag
actor = shu (the human)
X-TS-LLM-Agent:
claude-code/version research/version
batch-svc/version
✓ the human AND the whole chain

15

### Web Grounding for Enterprise

The agent searches and fetches from a cached Google index inside the VPC Service Controls perimeter, without reaching the public internet. The tradeoff is freshness: the slide lists refresh times of 6 or 24 hours.

[9:54](https://www.youtube.com/watch?v=wCIYViPd4SU&t=594s) [A diagram presents an agent using enterprise grounding and a cached index inside a service-controls perimeter.](https://assets.ai.engineer/sites/aiecode2025/sha256/2820c9264619e7b6d89faa9efdb8ba19818372683a1fa6c3895b8dd5047687de.webp)

Web Grounding for Enterprise: Stay in our network.

Safe Web

the public internet
never reached
cache only, under VPC-SC

VPC Service Controls perimeter

agent pod
no egress

ask
cited

Gemini Enterprise
Agent Platform · grounding
enterprise web search
URL context (cached fetch)

cached Google index
curated subset · finance / health / public
refresh 6h / 24h
a snapshot, not the live web

Under VPC-SC it serves from a cached index. No traffic leaves Google's premises; the open internet is never reached.

16

### How Agents Use Web Grounding

The network blocks external egress, and built-in WebSearch and WebFetch tools are denied. Agents use MCP, CLI, or code via skills to reach Web Grounding for Enterprise’s cached index and cited answers.

[11:20](https://www.youtube.com/watch?v=wCIYViPd4SU&t=680s) [A diagram shows blocked external network access and supported agent tools redirected to enterprise web grounding.](https://assets.ai.engineer/sites/aiecode2025/sha256/af287b7ce8b477c016c681f1c9c2c80241bb882295867d58a708c0f4cd0225da.webp)

How we ensure our agents use Web Grounding

the open internet

Block the network
all external egress · default-deny

your agent
WebSearch    WebFetch
built-in web tools · denied
won’t work
denied, so they can’t fail silently

MCP · CLI · code
the supported path · via skills
redirected →

Web Grounding for Enterprise
cached index · cited answers
never the live web

Built-in web tools are off so they can’t fail silently — web access is redirected through MCP, CLI, and code (skills): grounded, cached, cited.

Safe Web
17

### Tether Your Agents

Fang argues that tethering agents greatly reduces risk without losing expected value. The index lags, but tagging adds observability.

[12:19](https://www.youtube.com/watch?v=wCIYViPd4SU&t=739s) [Illustrations compare untethered and tethered agents beside a chart presenting tethering as reducing risk while preserving value.](https://assets.ai.engineer/sites/aiecode2025/sha256/66030342233552f118cf48b299075c9cc2f54b675c2b4881419e1e24c2e5d526.webp)

Tether your agents!

UNTETHERED
golden scissors, no leash

tether it

TETHERED
safety scissors · tracked

kept the value, cut the risk

Y-axis: value / return
X-axis: risk

tether it

tethered
no real value lost, far less risk

agents as you
huge value, huge risk

the index lags a little — but tagging adds far more observability

### The enterprise difference

Fang argues that enterprises can use their resources to reduce agent risk while retaining useful capabilities. Everyone here runs a cloud agent as themselves.

[13:02](https://www.youtube.com/watch?v=wCIYViPd4SU&t=782s) [An individual can avoid risk; an enterprise can engineer it down.](https://assets.ai.engineer/sites/aiecode2025/sha256/cfbef6708eeb5d81e1f0ce0291ee4716a5c39be51dd8ca897d6a40ca0447ad6e.webp)

THE ENTERPRISE DIFFERENCE

An individual can only avoid the risk.
An enterprise can engineer it down.

so everyone here runs a cloud agent as themselves.

### A tethered agent for everyone

Employees can use a managed agent or deploy their own in a managed cloud fleet. Both run as the user under shared guardrails; the managed agent is auto-updated.

[13:53](https://www.youtube.com/watch?v=wCIYViPd4SU&t=833s) [Diagram shows employees using managed agents or deploying custom agents in a managed cloud fleet under shared guardrails.](https://assets.ai.engineer/sites/aiecode2025/sha256/7a0e1071a89e4bca6399b6dfddfacb2f93f6da630f150fd9e6be9ebf4a205762.webp)

What we shipped: a tethered agent for everyone.

THE GUARDRAILS WE BUILT
run as you
no egress
web grounding
attributable

Result

every employee
technical or not

1 Use your agent
browser · mobile · Slack · CLI · API

2 Deploy your own
your custom agent
your code, still as you

managed cloud fleet
your namespace · runs as you · autoscaling
managed rollout

managed agent · as you
we run it, auto-updated

your own agent · as you
you deploy it, same guardrails

2σ
20

### Two Sigma is hiring

Two Sigma is hiring across GPU programming and infrastructure, agent tooling, distributed training, and applied AI engineering to build or overhaul its AI platform.

[14:50](https://www.youtube.com/watch?v=wCIYViPd4SU&t=890s) [Two Sigma hiring slide lists AI engineering, GPU infrastructure, serving, and training specialties, with a careers QR code.](https://assets.ai.engineer/sites/aiecode2025/sha256/18303a719e161db85e49240509fcdc72894a273ce33958a69237fe9735c4d3e3.webp)

TWO SIGMA

This talk covers the state of the Two Sigma AI Platform in 2025.

Want to build or see what we're working on now?
Or want to overhaul it?

We're hiring.

An AI-native platform, built from compound AI systems.

If you have experience in these areas, let's talk.

GPU Programming & Performance
GPU Infrastructure & Cluster Operations
LLM Serving, Agent Runtimes, & Developer Tooling
Distributed Training & Post-Training Research
Applied AI Engineering

Check out open roles at
twosigma.com/careers

### AI Engineer World's Fair

[21:01](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1261s) [AI Engineer World's Fair title in a white outlined box on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/b427c93fe649fc5a390b6f4089449b4b9bf428bdd78f0086389f113fb0bddea6.webp)

AI Engineer
World’s Fair

HTTPS://AI.ENGINEER

## Full transcript

[0:01](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1s) [music]

[0:13](https://www.youtube.com/watch?v=wCIYViPd4SU&t=13s) Great. Thanks everyone for coming. Uh

[0:15](https://www.youtube.com/watch?v=wCIYViPd4SU&t=15s) this talk is called Tethered. Our agents

[0:17](https://www.youtube.com/watch?v=wCIYViPd4SU&t=17s) are us. I'm Shu Fang from Two Sigma and

[0:21](https://www.youtube.com/watch?v=wCIYViPd4SU&t=21s) let's get started.

[0:23](https://www.youtube.com/watch?v=wCIYViPd4SU&t=23s) So just a quick explanation. Two Sigma

[0:26](https://www.youtube.com/watch?v=wCIYViPd4SU&t=26s) is a little quant fund. I will also take

[0:29](https://www.youtube.com/watch?v=wCIYViPd4SU&t=29s) the opportunity to explain that the name

[0:31](https://www.youtube.com/watch?v=wCIYViPd4SU&t=31s) ostensibly is not because we have two

[0:33](https://www.youtube.com/watch?v=wCIYViPd4SU&t=33s) co-founders who are very online but

[0:36](https://www.youtube.com/watch?v=wCIYViPd4SU&t=36s) because the two sigas are about the

[0:39](https://www.youtube.com/watch?v=wCIYViPd4SU&t=39s) volatility sigma the small sigma and the

[0:42](https://www.youtube.com/watch?v=wCIYViPd4SU&t=42s) large sigma sum. So by summing together

[0:44](https://www.youtube.com/watch?v=wCIYViPd4SU&t=44s) these individual volatilities we can uh

[0:47](https://www.youtube.com/watch?v=wCIYViPd4SU&t=47s) hedge the risk achieve differentiated

[0:50](https://www.youtube.com/watch?v=wCIYViPd4SU&t=50s) alpha.

[0:52](https://www.youtube.com/watch?v=wCIYViPd4SU&t=52s) Now because we are a hedge fund I have

[0:54](https://www.youtube.com/watch?v=wCIYViPd4SU&t=54s) to give you all this important legal

[0:56](https://www.youtube.com/watch?v=wCIYViPd4SU&t=56s) disclaimer. You don't have to read it.

[0:57](https://www.youtube.com/watch?v=wCIYViPd4SU&t=57s) It just has to be in this. And the TLDDR

[1:00](https://www.youtube.com/watch?v=wCIYViPd4SU&t=60s) is that I'm not trying to sell you on

[1:02](https://www.youtube.com/watch?v=wCIYViPd4SU&t=62s) anything. The views are mine and not

[1:05](https://www.youtube.com/watch?v=wCIYViPd4SU&t=65s) necessarily the companies. Any logos,

[1:08](https://www.youtube.com/watch?v=wCIYViPd4SU&t=68s) any other companies I mentioned here are

[1:09](https://www.youtube.com/watch?v=wCIYViPd4SU&t=69s) not me endorsing them or telling you to

[1:12](https://www.youtube.com/watch?v=wCIYViPd4SU&t=72s) buy their stocks or anything. It is

[1:13](https://www.youtube.com/watch?v=wCIYViPd4SU&t=73s) purely maybe coincidental.

[1:17](https://www.youtube.com/watch?v=wCIYViPd4SU&t=77s) But that also is meant to segue into the

[1:20](https://www.youtube.com/watch?v=wCIYViPd4SU&t=80s) fact that we are an old company. We're

[1:23](https://www.youtube.com/watch?v=wCIYViPd4SU&t=83s) 25 years old and clearly we're a very

[1:26](https://www.youtube.com/watch?v=wCIYViPd4SU&t=86s) regulated industry, but we've managed to

[1:30](https://www.youtube.com/watch?v=wCIYViPd4SU&t=90s) run an ecosystem where everyone at the

[1:32](https://www.youtube.com/watch?v=wCIYViPd4SU&t=92s) company has a cloud agent. And not only

[1:35](https://www.youtube.com/watch?v=wCIYViPd4SU&t=95s) that, but these agents run as their own

[1:36](https://www.youtube.com/watch?v=wCIYViPd4SU&t=96s) identity. So, we're going to explain how

[1:38](https://www.youtube.com/watch?v=wCIYViPd4SU&t=98s) we got here and why we're actually okay

[1:40](https://www.youtube.com/watch?v=wCIYViPd4SU&t=100s) with this.

[1:44](https://www.youtube.com/watch?v=wCIYViPd4SU&t=104s) So, we're first going to do a little

[1:45](https://www.youtube.com/watch?v=wCIYViPd4SU&t=105s) horror movie review. If any of you have

[1:47](https://www.youtube.com/watch?v=wCIYViPd4SU&t=107s) seen us, you don't have to pay attention

[1:49](https://www.youtube.com/watch?v=wCIYViPd4SU&t=109s) to this. defend if you haven't the TLDDR

[1:51](https://www.youtube.com/watch?v=wCIYViPd4SU&t=111s) of the movie is that everyone has these

[1:54](https://www.youtube.com/watch?v=wCIYViPd4SU&t=114s) doubles and these doubles are called

[1:57](https://www.youtube.com/watch?v=wCIYViPd4SU&t=117s) tethered when the doubles decide to run

[2:01](https://www.youtube.com/watch?v=wCIYViPd4SU&t=121s) loose and cause chaos and run around

[2:03](https://www.youtube.com/watch?v=wCIYViPd4SU&t=123s) with these golden scissors they're

[2:04](https://www.youtube.com/watch?v=wCIYViPd4SU&t=124s) called untetered and this is going to

[2:06](https://www.youtube.com/watch?v=wCIYViPd4SU&t=126s) somehow relate into my talk

[2:10](https://www.youtube.com/watch?v=wCIYViPd4SU&t=130s) so back in June 2025 you know cloud code

[2:13](https://www.youtube.com/watch?v=wCIYViPd4SU&t=133s) GA and all that stuff people started

[2:15](https://www.youtube.com/watch?v=wCIYViPd4SU&t=135s) using agents through the local computer

[2:19](https://www.youtube.com/watch?v=wCIYViPd4SU&t=139s) your local machine and it's very

[2:21](https://www.youtube.com/watch?v=wCIYViPd4SU&t=141s) powerful but one it was CLI constrained

[2:23](https://www.youtube.com/watch?v=wCIYViPd4SU&t=143s) and two it was localized right we wanted

[2:26](https://www.youtube.com/watch?v=wCIYViPd4SU&t=146s) to achieve a world where people could

[2:28](https://www.youtube.com/watch?v=wCIYViPd4SU&t=148s) use these agents from wherever they were

[2:31](https://www.youtube.com/watch?v=wCIYViPd4SU&t=151s) whether it be mobile through slack

[2:33](https://www.youtube.com/watch?v=wCIYViPd4SU&t=153s) through browsers but still have the

[2:36](https://www.youtube.com/watch?v=wCIYViPd4SU&t=156s) ability to run them remote and this is

[2:39](https://www.youtube.com/watch?v=wCIYViPd4SU&t=159s) important not just because of the

[2:40](https://www.youtube.com/watch?v=wCIYViPd4SU&t=160s) capability but many many people

[2:44](https://www.youtube.com/watch?v=wCIYViPd4SU&t=164s) technical or not are not comfortable

[2:45](https://www.youtube.com/watch?v=wCIYViPd4SU&t=165s) fully operating within a CLI so the

[2:48](https://www.youtube.com/watch?v=wCIYViPd4SU&t=168s) question became Okay, how do we actually

[2:50](https://www.youtube.com/watch?v=wCIYViPd4SU&t=170s) run these in terms of what identity they

[2:52](https://www.youtube.com/watch?v=wCIYViPd4SU&t=172s) run as?

[2:55](https://www.youtube.com/watch?v=wCIYViPd4SU&t=175s) The conventional wisdom is that you run

[2:57](https://www.youtube.com/watch?v=wCIYViPd4SU&t=177s) these as some machine identity that is

[3:00](https://www.youtube.com/watch?v=wCIYViPd4SU&t=180s) attached to your user in some way. You

[3:02](https://www.youtube.com/watch?v=wCIYViPd4SU&t=182s) have a shoe and you have a shoe agent.

[3:05](https://www.youtube.com/watch?v=wCIYViPd4SU&t=185s) But this quickly collapses and we found

[3:07](https://www.youtube.com/watch?v=wCIYViPd4SU&t=187s) this collapsed because of all the

[3:09](https://www.youtube.com/watch?v=wCIYViPd4SU&t=189s) reasons that you can imagine, right?

[3:10](https://www.youtube.com/watch?v=wCIYViPd4SU&t=190s) It's very hard to keep permissions in

[3:12](https://www.youtube.com/watch?v=wCIYViPd4SU&t=192s) sync. Anytime you're dealing with

[3:13](https://www.youtube.com/watch?v=wCIYViPd4SU&t=193s) software licensing, now you have to deal

[3:15](https://www.youtube.com/watch?v=wCIYViPd4SU&t=195s) with two licenses.

[3:17](https://www.youtube.com/watch?v=wCIYViPd4SU&t=197s) uh there's certain systems that do not

[3:19](https://www.youtube.com/watch?v=wCIYViPd4SU&t=199s) support multiple identities interacting

[3:21](https://www.youtube.com/watch?v=wCIYViPd4SU&t=201s) with the same underlying data. You know,

[3:23](https://www.youtube.com/watch?v=wCIYViPd4SU&t=203s) stuff like Google Workspace, your

[3:25](https://www.youtube.com/watch?v=wCIYViPd4SU&t=205s) emails, etc. And then how some systems

[3:28](https://www.youtube.com/watch?v=wCIYViPd4SU&t=208s) are going to block as a first step. So

[3:31](https://www.youtube.com/watch?v=wCIYViPd4SU&t=211s) you have to you're just going over the

[3:33](https://www.youtube.com/watch?v=wCIYViPd4SU&t=213s) barrier of entry. And then you also have

[3:35](https://www.youtube.com/watch?v=wCIYViPd4SU&t=215s) to figure out how you actually manage

[3:37](https://www.youtube.com/watch?v=wCIYViPd4SU&t=217s) the public and private boundaries.

[3:41](https://www.youtube.com/watch?v=wCIYViPd4SU&t=221s) So obviously it's like why don't we just

[3:43](https://www.youtube.com/watch?v=wCIYViPd4SU&t=223s) run these as the user, right? How do how

[3:45](https://www.youtube.com/watch?v=wCIYViPd4SU&t=225s) do we run these remotely as the exact

[3:48](https://www.youtube.com/watch?v=wCIYViPd4SU&t=228s) same user identity? And as a result, all

[3:50](https://www.youtube.com/watch?v=wCIYViPd4SU&t=230s) the capabilities, all the access, all

[3:52](https://www.youtube.com/watch?v=wCIYViPd4SU&t=232s) those previous constraints are no longer

[3:56](https://www.youtube.com/watch?v=wCIYViPd4SU&t=236s) valid.

[3:59](https://www.youtube.com/watch?v=wCIYViPd4SU&t=239s) And we already had the info for this and

[4:01](https://www.youtube.com/watch?v=wCIYViPd4SU&t=241s) I imagine a lot of you do too. If you

[4:03](https://www.youtube.com/watch?v=wCIYViPd4SU&t=243s) don't, I would uh encourage investing in

[4:06](https://www.youtube.com/watch?v=wCIYViPd4SU&t=246s) it, which is that you know you could

[4:09](https://www.youtube.com/watch?v=wCIYViPd4SU&t=249s) have a Kubernetes cluster. You have all

[4:11](https://www.youtube.com/watch?v=wCIYViPd4SU&t=251s) all of your clusters, your regions, etc.

[4:13](https://www.youtube.com/watch?v=wCIYViPd4SU&t=253s) And you have name spaces for

[4:15](https://www.youtube.com/watch?v=wCIYViPd4SU&t=255s) individuals, right? And the reason we

[4:17](https://www.youtube.com/watch?v=wCIYViPd4SU&t=257s) had this is because we often already

[4:19](https://www.youtube.com/watch?v=wCIYViPd4SU&t=259s) needed this capability not for the

[4:21](https://www.youtube.com/watch?v=wCIYViPd4SU&t=261s) agentic purposes, but for all the

[4:23](https://www.youtube.com/watch?v=wCIYViPd4SU&t=263s) automated operations that we need to do

[4:26](https://www.youtube.com/watch?v=wCIYViPd4SU&t=266s) that did not suit confinement to

[4:28](https://www.youtube.com/watch?v=wCIYViPd4SU&t=268s) someone's local machine. So we'd run

[4:30](https://www.youtube.com/watch?v=wCIYViPd4SU&t=270s) automated jobs, you know, code

[4:32](https://www.youtube.com/watch?v=wCIYViPd4SU&t=272s) containers usually operate on this

[4:33](https://www.youtube.com/watch?v=wCIYViPd4SU&t=273s) principle, research notebooks, etc. And

[4:36](https://www.youtube.com/watch?v=wCIYViPd4SU&t=276s) every single user already had these

[4:38](https://www.youtube.com/watch?v=wCIYViPd4SU&t=278s) namespaces existing in every single

[4:40](https://www.youtube.com/watch?v=wCIYViPd4SU&t=280s) region and everything in it runs as the

[4:42](https://www.youtube.com/watch?v=wCIYViPd4SU&t=282s) user.

[4:43](https://www.youtube.com/watch?v=wCIYViPd4SU&t=283s) A very simplistic way of how this works.

[4:46](https://www.youtube.com/watch?v=wCIYViPd4SU&t=286s) Some trigger is going in to your

[4:49](https://www.youtube.com/watch?v=wCIYViPd4SU&t=289s) controller and it's saying, "Hey, I need

[4:51](https://www.youtube.com/watch?v=wCIYViPd4SU&t=291s) to spin up some compute resources. You

[4:53](https://www.youtube.com/watch?v=wCIYViPd4SU&t=293s) have a separate identity service that a

[4:56](https://www.youtube.com/watch?v=wCIYViPd4SU&t=296s) sidecar in the pod pulls down from to

[4:59](https://www.youtube.com/watch?v=wCIYViPd4SU&t=299s) allow your actual containers

[5:01](https://www.youtube.com/watch?v=wCIYViPd4SU&t=301s) to run and mount that identity and it

[5:03](https://www.youtube.com/watch?v=wCIYViPd4SU&t=303s) runs as you.

[5:07](https://www.youtube.com/watch?v=wCIYViPd4SU&t=307s) So of course there are big dangers with

[5:09](https://www.youtube.com/watch?v=wCIYViPd4SU&t=309s) this right and you know the first danger

[5:12](https://www.youtube.com/watch?v=wCIYViPd4SU&t=312s) you may imagine is an internal danger.

[5:14](https://www.youtube.com/watch?v=wCIYViPd4SU&t=314s) How do you actually differentiate who or

[5:17](https://www.youtube.com/watch?v=wCIYViPd4SU&t=317s) what took action right? You have you and

[5:20](https://www.youtube.com/watch?v=wCIYViPd4SU&t=320s) your U agent are now the exact same

[5:22](https://www.youtube.com/watch?v=wCIYViPd4SU&t=322s) identity. That's why I grew this

[5:23](https://www.youtube.com/watch?v=wCIYViPd4SU&t=323s) mustache so you could tell the

[5:25](https://www.youtube.com/watch?v=wCIYViPd4SU&t=325s) difference between us for now. But uh

[5:27](https://www.youtube.com/watch?v=wCIYViPd4SU&t=327s) you really want to know that

[5:29](https://www.youtube.com/watch?v=wCIYViPd4SU&t=329s) differentiation because certain actions

[5:31](https://www.youtube.com/watch?v=wCIYViPd4SU&t=331s) that can be taken. You want to audit,

[5:34](https://www.youtube.com/watch?v=wCIYViPd4SU&t=334s) you possibly want to block and you want

[5:37](https://www.youtube.com/watch?v=wCIYViPd4SU&t=337s) to just have the trace, right? You want

[5:40](https://www.youtube.com/watch?v=wCIYViPd4SU&t=340s) to have the attribution to determine,

[5:41](https://www.youtube.com/watch?v=wCIYViPd4SU&t=341s) hey, was it someone operating as the

[5:44](https://www.youtube.com/watch?v=wCIYViPd4SU&t=344s) human operating purely human actions or

[5:47](https://www.youtube.com/watch?v=wCIYViPd4SU&t=347s) was it the agent identity doing these

[5:49](https://www.youtube.com/watch?v=wCIYViPd4SU&t=349s) things?

[5:53](https://www.youtube.com/watch?v=wCIYViPd4SU&t=353s) Another danger and perhaps a bigger one

[5:56](https://www.youtube.com/watch?v=wCIYViPd4SU&t=356s) is we all know that for all of these

[5:58](https://www.youtube.com/watch?v=wCIYViPd4SU&t=358s) capabilities and LOMs in general, it's

[6:00](https://www.youtube.com/watch?v=wCIYViPd4SU&t=360s) essential you have access to the

[6:02](https://www.youtube.com/watch?v=wCIYViPd4SU&t=362s) external web. These are point in time

[6:04](https://www.youtube.com/watch?v=wCIYViPd4SU&t=364s) mathematical functions that cannot

[6:07](https://www.youtube.com/watch?v=wCIYViPd4SU&t=367s) actually update based on current data.

[6:09](https://www.youtube.com/watch?v=wCIYViPd4SU&t=369s) So it's like open internet access.

[6:11](https://www.youtube.com/watch?v=wCIYViPd4SU&t=371s) That's why it's a core capability, web

[6:13](https://www.youtube.com/watch?v=wCIYViPd4SU&t=373s) search, web fetch tools, right? The

[6:15](https://www.youtube.com/watch?v=wCIYViPd4SU&t=375s) problem is once you have that

[6:17](https://www.youtube.com/watch?v=wCIYViPd4SU&t=377s) capability, you leave yourself open to

[6:19](https://www.youtube.com/watch?v=wCIYViPd4SU&t=379s) huge vulnerability vectors. One of which

[6:22](https://www.youtube.com/watch?v=wCIYViPd4SU&t=382s) is exfiltration risk. This is one we are

[6:25](https://www.youtube.com/watch?v=wCIYViPd4SU&t=385s) deeply concerned with in terms of

[6:26](https://www.youtube.com/watch?v=wCIYViPd4SU&t=386s) possibly losing IP, you know, just

[6:28](https://www.youtube.com/watch?v=wCIYViPd4SU&t=388s) exposing our sensitive information. but

[6:31](https://www.youtube.com/watch?v=wCIYViPd4SU&t=391s) also certainly the possibility of

[6:34](https://www.youtube.com/watch?v=wCIYViPd4SU&t=394s) untrusted content flowing back in and

[6:36](https://www.youtube.com/watch?v=wCIYViPd4SU&t=396s) you know prompt injection just malware

[6:39](https://www.youtube.com/watch?v=wCIYViPd4SU&t=399s) and vulnerabilities are all big risks

[6:41](https://www.youtube.com/watch?v=wCIYViPd4SU&t=401s) there and then something we separately

[6:43](https://www.youtube.com/watch?v=wCIYViPd4SU&t=403s) deal with is just the ability to make

[6:45](https://www.youtube.com/watch?v=wCIYViPd4SU&t=405s) sure we don't

[6:47](https://www.youtube.com/watch?v=wCIYViPd4SU&t=407s) u use licensed content without the right

[6:50](https://www.youtube.com/watch?v=wCIYViPd4SU&t=410s) copyrights or actual licensing right you

[6:53](https://www.youtube.com/watch?v=wCIYViPd4SU&t=413s) can map this to the golden scissors that

[6:56](https://www.youtube.com/watch?v=wCIYViPd4SU&t=416s) they use and us so this is kind of our

[6:58](https://www.youtube.com/watch?v=wCIYViPd4SU&t=418s) biggest fear to be honest

[7:01](https://www.youtube.com/watch?v=wCIYViPd4SU&t=421s) So we are a finance firm and in finance

[7:05](https://www.youtube.com/watch?v=wCIYViPd4SU&t=425s) there's a concept of obviously risk and

[7:07](https://www.youtube.com/watch?v=wCIYViPd4SU&t=427s) return. So when we think about what is

[7:11](https://www.youtube.com/watch?v=wCIYViPd4SU&t=431s) the positioning on the risk and return

[7:13](https://www.youtube.com/watch?v=wCIYViPd4SU&t=433s) graph there's huge value in allowing

[7:16](https://www.youtube.com/watch?v=wCIYViPd4SU&t=436s) agents to run you but also there's very

[7:18](https://www.youtube.com/watch?v=wCIYViPd4SU&t=438s) high risk. What we generally want to do

[7:21](https://www.youtube.com/watch?v=wCIYViPd4SU&t=441s) is make sure we capture as much of the

[7:23](https://www.youtube.com/watch?v=wCIYViPd4SU&t=443s) value as possible but reduce the risk.

[7:26](https://www.youtube.com/watch?v=wCIYViPd4SU&t=446s) We're optimizing that ratio of return

[7:28](https://www.youtube.com/watch?v=wCIYViPd4SU&t=448s) over risk. Some of you may know the

[7:30](https://www.youtube.com/watch?v=wCIYViPd4SU&t=450s) sharp ratio. We're looking at that from

[7:32](https://www.youtube.com/watch?v=wCIYViPd4SU&t=452s) the perspective of how do we let agents

[7:35](https://www.youtube.com/watch?v=wCIYViPd4SU&t=455s) run as users and optimize that return.

[7:38](https://www.youtube.com/watch?v=wCIYViPd4SU&t=458s) And the ways we need to do this, right,

[7:40](https://www.youtube.com/watch?v=wCIYViPd4SU&t=460s) are to solve those two critical

[7:41](https://www.youtube.com/watch?v=wCIYViPd4SU&t=461s) problems. One, differentiating access

[7:44](https://www.youtube.com/watch?v=wCIYViPd4SU&t=464s) attributed to the human versus the

[7:46](https://www.youtube.com/watch?v=wCIYViPd4SU&t=466s) agent. And two, somehow getting safe web

[7:50](https://www.youtube.com/watch?v=wCIYViPd4SU&t=470s) access in place.

[7:54](https://www.youtube.com/watch?v=wCIYViPd4SU&t=474s) So the first thing we did is this

[7:56](https://www.youtube.com/watch?v=wCIYViPd4SU&t=476s) attribution step, right?

[7:58](https://www.youtube.com/watch?v=wCIYViPd4SU&t=478s) And how we did this is we use a header

[8:02](https://www.youtube.com/watch?v=wCIYViPd4SU&t=482s) and we make sure that every single agent

[8:04](https://www.youtube.com/watch?v=wCIYViPd4SU&t=484s) continues to append to that header. And

[8:07](https://www.youtube.com/watch?v=wCIYViPd4SU&t=487s) this is something we've all hopefully

[8:10](https://www.youtube.com/watch?v=wCIYViPd4SU&t=490s) done in some way, right? Trace IDs.

[8:12](https://www.youtube.com/watch?v=wCIYViPd4SU&t=492s) You've you've all done this in

[8:13](https://www.youtube.com/watch?v=wCIYViPd4SU&t=493s) deterministic code. Making sure that

[8:15](https://www.youtube.com/watch?v=wCIYViPd4SU&t=495s) your observability stack propagates

[8:17](https://www.youtube.com/watch?v=wCIYViPd4SU&t=497s) through a trace ID through disparate

[8:19](https://www.youtube.com/watch?v=wCIYViPd4SU&t=499s) systems. How we did it is very similar

[8:22](https://www.youtube.com/watch?v=wCIYViPd4SU&t=502s) to how you would do it for trace ID

[8:24](https://www.youtube.com/watch?v=wCIYViPd4SU&t=504s) except we are dealing with a certain

[8:27](https://www.youtube.com/watch?v=wCIYViPd4SU&t=507s) difference in the control vector which

[8:29](https://www.youtube.com/watch?v=wCIYViPd4SU&t=509s) is the agent itself right and you can

[8:32](https://www.youtube.com/watch?v=wCIYViPd4SU&t=512s) force you know using certain HP clients

[8:35](https://www.youtube.com/watch?v=wCIYViPd4SU&t=515s) using MCPS using skills to make sure

[8:38](https://www.youtube.com/watch?v=wCIYViPd4SU&t=518s) that that header initially gets

[8:40](https://www.youtube.com/watch?v=wCIYViPd4SU&t=520s) populated and everywhere else along the

[8:42](https://www.youtube.com/watch?v=wCIYViPd4SU&t=522s) way continues to be populated right you

[8:44](https://www.youtube.com/watch?v=wCIYViPd4SU&t=524s) have a lot more deterministic control

[8:46](https://www.youtube.com/watch?v=wCIYViPd4SU&t=526s) over agents and the harnesses and the

[8:48](https://www.youtube.com/watch?v=wCIYViPd4SU&t=528s) frameworks than you may ink and you can

[8:50](https://www.youtube.com/watch?v=wCIYViPd4SU&t=530s) enforce it with some of the already

[8:53](https://www.youtube.com/watch?v=wCIYViPd4SU&t=533s) existing primitives.

[8:56](https://www.youtube.com/watch?v=wCIYViPd4SU&t=536s) Now this gets very interesting because

[8:59](https://www.youtube.com/watch?v=wCIYViPd4SU&t=539s) this is not only giving us the proper

[9:02](https://www.youtube.com/watch?v=wCIYViPd4SU&t=542s) identification of who did something

[9:05](https://www.youtube.com/watch?v=wCIYViPd4SU&t=545s) right it actually goes beyond that and

[9:08](https://www.youtube.com/watch?v=wCIYViPd4SU&t=548s) no longer are we confined by just

[9:10](https://www.youtube.com/watch?v=wCIYViPd4SU&t=550s) knowing the act identity but we also

[9:13](https://www.youtube.com/watch?v=wCIYViPd4SU&t=553s) actually get the full provenence through

[9:15](https://www.youtube.com/watch?v=wCIYViPd4SU&t=555s) the system right as we deal with

[9:17](https://www.youtube.com/watch?v=wCIYViPd4SU&t=557s) multiple steps in the system we are able

[9:20](https://www.youtube.com/watch?v=wCIYViPd4SU&t=560s) to replay the entire chain of actions

[9:22](https://www.youtube.com/watch?v=wCIYViPd4SU&t=562s) that actually led to some end result. So

[9:25](https://www.youtube.com/watch?v=wCIYViPd4SU&t=565s) the comparison here is if we had used

[9:28](https://www.youtube.com/watch?v=wCIYViPd4SU&t=568s) that shoe agent identity we wouldn't

[9:30](https://www.youtube.com/watch?v=wCIYViPd4SU&t=570s) have this and we would just know that at

[9:32](https://www.youtube.com/watch?v=wCIYViPd4SU&t=572s) some point shoe agent triggered this

[9:34](https://www.youtube.com/watch?v=wCIYViPd4SU&t=574s) initial flow into the span but we don't

[9:37](https://www.youtube.com/watch?v=wCIYViPd4SU&t=577s) actually know hey those subsequent

[9:40](https://www.youtube.com/watch?v=wCIYViPd4SU&t=580s) actions how do we properly trace back to

[9:42](https://www.youtube.com/watch?v=wCIYViPd4SU&t=582s) that origination point with this header

[9:46](https://www.youtube.com/watch?v=wCIYViPd4SU&t=586s) this trace ID we get that full

[9:48](https://www.youtube.com/watch?v=wCIYViPd4SU&t=588s) propagation and the actor is still me

[9:51](https://www.youtube.com/watch?v=wCIYViPd4SU&t=591s) right it's still my identity

[9:56](https://www.youtube.com/watch?v=wCIYViPd4SU&t=596s) And the second step that we needed to

[9:58](https://www.youtube.com/watch?v=wCIYViPd4SU&t=598s) fix is this web access. Right? A lot of

[10:01](https://www.youtube.com/watch?v=wCIYViPd4SU&t=601s) web access these days uses indexes for

[10:05](https://www.youtube.com/watch?v=wCIYViPd4SU&t=605s) search. Right? I think cloud code's

[10:07](https://www.youtube.com/watch?v=wCIYViPd4SU&t=607s) native one is Brave web browser and it

[10:09](https://www.youtube.com/watch?v=wCIYViPd4SU&t=609s) uses a Brave index. Well, we were like,

[10:12](https://www.youtube.com/watch?v=wCIYViPd4SU&t=612s) hey, why don't we see what Google has,

[10:14](https://www.youtube.com/watch?v=wCIYViPd4SU&t=614s) right? Google is at its core hopefully

[10:17](https://www.youtube.com/watch?v=wCIYViPd4SU&t=617s) still a search company and they do this

[10:20](https://www.youtube.com/watch?v=wCIYViPd4SU&t=620s) index generation already. And it turns

[10:22](https://www.youtube.com/watch?v=wCIYViPd4SU&t=622s) out they actually do offer something

[10:24](https://www.youtube.com/watch?v=wCIYViPd4SU&t=624s) specifically for regulated industries

[10:27](https://www.youtube.com/watch?v=wCIYViPd4SU&t=627s) like ours that allows you to use their

[10:29](https://www.youtube.com/watch?v=wCIYViPd4SU&t=629s) web index but within your existing VPC

[10:32](https://www.youtube.com/watch?v=wCIYViPd4SU&t=632s) your you know network controls right and

[10:34](https://www.youtube.com/watch?v=wCIYViPd4SU&t=634s) it's called web grounding for

[10:36](https://www.youtube.com/watch?v=wCIYViPd4SU&t=636s) enterprise. It basically works like this

[10:38](https://www.youtube.com/watch?v=wCIYViPd4SU&t=638s) where it's still within the exact same

[10:41](https://www.youtube.com/watch?v=wCIYViPd4SU&t=641s) network boundary where you're probably

[10:43](https://www.youtube.com/watch?v=wCIYViPd4SU&t=643s) running your cloud agents and stuff like

[10:44](https://www.youtube.com/watch?v=wCIYViPd4SU&t=644s) that and offers two core capabilities

[10:48](https://www.youtube.com/watch?v=wCIYViPd4SU&t=648s) search and fetch. Right? So the exact

[10:50](https://www.youtube.com/watch?v=wCIYViPd4SU&t=650s) capabilities we want to mirror, we

[10:53](https://www.youtube.com/watch?v=wCIYViPd4SU&t=653s) leverage that. We have all these

[10:54](https://www.youtube.com/watch?v=wCIYViPd4SU&t=654s) guarantees. There's one tiny downside,

[10:57](https://www.youtube.com/watch?v=wCIYViPd4SU&t=657s) which is the data is obviously not going

[10:59](https://www.youtube.com/watch?v=wCIYViPd4SU&t=659s) to be completely fresh, right? And the

[11:02](https://www.youtube.com/watch?v=wCIYViPd4SU&t=662s) constraints around this last I checked,

[11:05](https://www.youtube.com/watch?v=wCIYViPd4SU&t=665s) it's fresh within 24 hours. And for more

[11:07](https://www.youtube.com/watch?v=wCIYViPd4SU&t=667s) regularly updated websites, it's fresh

[11:09](https://www.youtube.com/watch?v=wCIYViPd4SU&t=669s) within 6 hours. But for most use cases

[11:12](https://www.youtube.com/watch?v=wCIYViPd4SU&t=672s) that you may have for agents, that's

[11:13](https://www.youtube.com/watch?v=wCIYViPd4SU&t=673s) probably more than sufficient and

[11:15](https://www.youtube.com/watch?v=wCIYViPd4SU&t=675s) completely removes this external egress

[11:17](https://www.youtube.com/watch?v=wCIYViPd4SU&t=677s) vulnerability vector.

[11:21](https://www.youtube.com/watch?v=wCIYViPd4SU&t=681s) Now the second question is how do we

[11:23](https://www.youtube.com/watch?v=wCIYViPd4SU&t=683s) actually ensure the agents use web

[11:24](https://www.youtube.com/watch?v=wCIYViPd4SU&t=684s) grounding and again this is very

[11:28](https://www.youtube.com/watch?v=wCIYViPd4SU&t=688s) simple with the existing primitives

[11:29](https://www.youtube.com/watch?v=wCIYViPd4SU&t=689s) right you just need to make sure that

[11:31](https://www.youtube.com/watch?v=wCIYViPd4SU&t=691s) they don't get confused and you

[11:34](https://www.youtube.com/watch?v=wCIYViPd4SU&t=694s) certainly block the access itself but

[11:36](https://www.youtube.com/watch?v=wCIYViPd4SU&t=696s) just for user experience and stuff like

[11:38](https://www.youtube.com/watch?v=wCIYViPd4SU&t=698s) that you need to make sure those tools

[11:40](https://www.youtube.com/watch?v=wCIYViPd4SU&t=700s) themselves that are already existing and

[11:42](https://www.youtube.com/watch?v=wCIYViPd4SU&t=702s) primitive and native to these agent

[11:44](https://www.youtube.com/watch?v=wCIYViPd4SU&t=704s) harnesses and frameworks and such are

[11:47](https://www.youtube.com/watch?v=wCIYViPd4SU&t=707s) actually blocked right again here's

[11:49](https://www.youtube.com/watch?v=wCIYViPd4SU&t=709s) cloud code example. I think every other

[11:50](https://www.youtube.com/watch?v=wCIYViPd4SU&t=710s) hotness has the same thing. Web search,

[11:52](https://www.youtube.com/watch?v=wCIYViPd4SU&t=712s) web fetch. We just deny those tools.

[11:54](https://www.youtube.com/watch?v=wCIYViPd4SU&t=714s) It's like, hey, you can't even use

[11:55](https://www.youtube.com/watch?v=wCIYViPd4SU&t=715s) these. These are not even in your suite

[11:57](https://www.youtube.com/watch?v=wCIYViPd4SU&t=717s) of tools available to you. Instead, we

[12:00](https://www.youtube.com/watch?v=wCIYViPd4SU&t=720s) use the redirection going through, you

[12:02](https://www.youtube.com/watch?v=wCIYViPd4SU&t=722s) know, MCP CLI and actual client code

[12:06](https://www.youtube.com/watch?v=wCIYViPd4SU&t=726s) using the supported paths, uh, skills,

[12:08](https://www.youtube.com/watch?v=wCIYViPd4SU&t=728s) whatever to make sure that whenever

[12:10](https://www.youtube.com/watch?v=wCIYViPd4SU&t=730s) someone does need the capabilities of

[12:12](https://www.youtube.com/watch?v=wCIYViPd4SU&t=732s) web access, it goes through that web

[12:14](https://www.youtube.com/watch?v=wCIYViPd4SU&t=734s) grounding cache index.

[12:21](https://www.youtube.com/watch?v=wCIYViPd4SU&t=741s) So takeaways from this talk basically

[12:24](https://www.youtube.com/watch?v=wCIYViPd4SU&t=744s) make sure you ted your agents right

[12:26](https://www.youtube.com/watch?v=wCIYViPd4SU&t=746s) letting them run around untetered you

[12:28](https://www.youtube.com/watch?v=wCIYViPd4SU&t=748s) know is very dangerous we want to tar

[12:30](https://www.youtube.com/watch?v=wCIYViPd4SU&t=750s) them and it's much safer to do so and in

[12:32](https://www.youtube.com/watch?v=wCIYViPd4SU&t=752s) fact if we go back to that initial slide

[12:34](https://www.youtube.com/watch?v=wCIYViPd4SU&t=754s) of how we consider this relative to the

[12:36](https://www.youtube.com/watch?v=wCIYViPd4SU&t=756s) risk and expected return because of some

[12:40](https://www.youtube.com/watch?v=wCIYViPd4SU&t=760s) of the things we found while doing this

[12:42](https://www.youtube.com/watch?v=wCIYViPd4SU&t=762s) we actually believe we didn't lose

[12:45](https://www.youtube.com/watch?v=wCIYViPd4SU&t=765s) expected value while huge hugely

[12:47](https://www.youtube.com/watch?v=wCIYViPd4SU&t=767s) reducing the risk, right? So, the index

[12:50](https://www.youtube.com/watch?v=wCIYViPd4SU&t=770s) certainly lags, but we get a ton more

[12:52](https://www.youtube.com/watch?v=wCIYViPd4SU&t=772s) observability by just using that tagging

[12:55](https://www.youtube.com/watch?v=wCIYViPd4SU&t=775s) primitive versus the actual uh just pure

[12:59](https://www.youtube.com/watch?v=wCIYViPd4SU&t=779s) identity verification.

[13:03](https://www.youtube.com/watch?v=wCIYViPd4SU&t=783s) And I think this is [sighs and gasps]

[13:06](https://www.youtube.com/watch?v=wCIYViPd4SU&t=786s) one thing people should really consider,

[13:08](https://www.youtube.com/watch?v=wCIYViPd4SU&t=788s) especially people working at companies,

[13:09](https://www.youtube.com/watch?v=wCIYViPd4SU&t=789s) enterprises, which is that there are a

[13:12](https://www.youtube.com/watch?v=wCIYViPd4SU&t=792s) ton of things happening in the Genai

[13:15](https://www.youtube.com/watch?v=wCIYViPd4SU&t=795s) landscape that are probably scary to us

[13:18](https://www.youtube.com/watch?v=wCIYViPd4SU&t=798s) that make your security teams really

[13:20](https://www.youtube.com/watch?v=wCIYViPd4SU&t=800s) afraid that feel like, hey, they are too

[13:23](https://www.youtube.com/watch?v=wCIYViPd4SU&t=803s) far on the frontier, right? You you're

[13:25](https://www.youtube.com/watch?v=wCIYViPd4SU&t=805s) like, I wouldn't run this locally. I

[13:26](https://www.youtube.com/watch?v=wCIYViPd4SU&t=806s) wouldn't run a open cloud agent on my

[13:30](https://www.youtube.com/watch?v=wCIYViPd4SU&t=810s) local machine with full permissions,

[13:32](https://www.youtube.com/watch?v=wCIYViPd4SU&t=812s) right? There's all these horror stories

[13:34](https://www.youtube.com/watch?v=wCIYViPd4SU&t=814s) and you know various anecdotes about why

[13:37](https://www.youtube.com/watch?v=wCIYViPd4SU&t=817s) this is bad. But in an enterprise again

[13:41](https://www.youtube.com/watch?v=wCIYViPd4SU&t=821s) you can figure out how to leverage your

[13:43](https://www.youtube.com/watch?v=wCIYViPd4SU&t=823s) enterprise resources to actually reduce

[13:45](https://www.youtube.com/watch?v=wCIYViPd4SU&t=825s) those risk factors and get the real

[13:47](https://www.youtube.com/watch?v=wCIYViPd4SU&t=827s) value out of the capabilities and this

[13:50](https://www.youtube.com/watch?v=wCIYViPd4SU&t=830s) is where you should be investing that

[13:51](https://www.youtube.com/watch?v=wCIYViPd4SU&t=831s) time.

[13:54](https://www.youtube.com/watch?v=wCIYViPd4SU&t=834s) So what we ultimately shipped is this

[13:57](https://www.youtube.com/watch?v=wCIYViPd4SU&t=837s) entire framework, right? We have the

[13:59](https://www.youtube.com/watch?v=wCIYViPd4SU&t=839s) ability to run cloud agents as user

[14:05](https://www.youtube.com/watch?v=wCIYViPd4SU&t=845s) identities uh because of all of those

[14:07](https://www.youtube.com/watch?v=wCIYViPd4SU&t=847s) guard rails and vectors we put in place

[14:10](https://www.youtube.com/watch?v=wCIYViPd4SU&t=850s) and using different kind of interface

[14:13](https://www.youtube.com/watch?v=wCIYViPd4SU&t=853s) vectors to actually operate with them so

[14:15](https://www.youtube.com/watch?v=wCIYViPd4SU&t=855s) that people who are not comfortable with

[14:17](https://www.youtube.com/watch?v=wCIYViPd4SU&t=857s) CLIs can leverage them but certainly for

[14:18](https://www.youtube.com/watch?v=wCIYViPd4SU&t=858s) other cases as well. And as part of

[14:20](https://www.youtube.com/watch?v=wCIYViPd4SU&t=860s) that, we made sure to ship out just a

[14:22](https://www.youtube.com/watch?v=wCIYViPd4SU&t=862s) managed fleet of cloud, you know,

[14:25](https://www.youtube.com/watch?v=wCIYViPd4SU&t=865s) whatever agents for every single user in

[14:28](https://www.youtube.com/watch?v=wCIYViPd4SU&t=868s) this remote fashion that they can

[14:30](https://www.youtube.com/watch?v=wCIYViPd4SU&t=870s) already interact with so that we can

[14:31](https://www.youtube.com/watch?v=wCIYViPd4SU&t=871s) continue to deploy and improve what is

[14:34](https://www.youtube.com/watch?v=wCIYViPd4SU&t=874s) actually available to individual users.

[14:37](https://www.youtube.com/watch?v=wCIYViPd4SU&t=877s) But also the core capability itself of

[14:39](https://www.youtube.com/watch?v=wCIYViPd4SU&t=879s) being able for every anyone at the

[14:41](https://www.youtube.com/watch?v=wCIYViPd4SU&t=881s) company to deploy an agent that runs in

[14:44](https://www.youtube.com/watch?v=wCIYViPd4SU&t=884s) the cloud remotely with their full

[14:46](https://www.youtube.com/watch?v=wCIYViPd4SU&t=886s) identity is there and is something we

[14:48](https://www.youtube.com/watch?v=wCIYViPd4SU&t=888s) are comfortable with.

[14:51](https://www.youtube.com/watch?v=wCIYViPd4SU&t=891s) So to finish up, uh, everything I talked

[14:54](https://www.youtube.com/watch?v=wCIYViPd4SU&t=894s) about actually happened last year. So if

[14:56](https://www.youtube.com/watch?v=wCIYViPd4SU&t=896s) you are interested at all in wanting to

[14:59](https://www.youtube.com/watch?v=wCIYViPd4SU&t=899s) build and see what we're working on now,

[15:01](https://www.youtube.com/watch?v=wCIYViPd4SU&t=901s) or even better, if you're like, that was

[15:04](https://www.youtube.com/watch?v=wCIYViPd4SU&t=904s) horrible, we could do so much better. We

[15:07](https://www.youtube.com/watch?v=wCIYViPd4SU&t=907s) are hiring and we encourage you to

[15:09](https://www.youtube.com/watch?v=wCIYViPd4SU&t=909s) apply. If you have any experience in any

[15:11](https://www.youtube.com/watch?v=wCIYViPd4SU&t=911s) of these domains,

[15:13](https://www.youtube.com/watch?v=wCIYViPd4SU&t=913s) you can check that QR code, check that

[15:16](https://www.youtube.com/watch?v=wCIYViPd4SU&t=916s) link. Yeah, that's it. Any questions?

[15:20](https://www.youtube.com/watch?v=wCIYViPd4SU&t=920s) [applause]

[15:26](https://www.youtube.com/watch?v=wCIYViPd4SU&t=926s) >> What do you think about local connected

[15:28](https://www.youtube.com/watch?v=wCIYViPd4SU&t=928s) to agents for enterprises?

[15:32](https://www.youtube.com/watch?v=wCIYViPd4SU&t=932s) >> Uh, not the views of my company, but

[15:36](https://www.youtube.com/watch?v=wCIYViPd4SU&t=936s) personally I I think that is

[15:38](https://www.youtube.com/watch?v=wCIYViPd4SU&t=938s) >> question.

[15:39](https://www.youtube.com/watch?v=wCIYViPd4SU&t=939s) >> Yeah, sorry. His question was how do how

[15:40](https://www.youtube.com/watch?v=wCIYViPd4SU&t=940s) do I view local LLMs for enterprise

[15:43](https://www.youtube.com/watch?v=wCIYViPd4SU&t=943s) usage? And I think local in the sense

[15:47](https://www.youtube.com/watch?v=wCIYViPd4SU&t=947s) that we manage ourselves is probably

[15:49](https://www.youtube.com/watch?v=wCIYViPd4SU&t=949s) where we eventually want to go for a lot

[15:51](https://www.youtube.com/watch?v=wCIYViPd4SU&t=951s) of our token use and inference because

[15:54](https://www.youtube.com/watch?v=wCIYViPd4SU&t=954s) of cost because of deprecations because

[15:56](https://www.youtube.com/watch?v=wCIYViPd4SU&t=956s) of you know every time Frontier Lab

[15:59](https://www.youtube.com/watch?v=wCIYViPd4SU&t=959s) drops a new model you see some

[16:00](https://www.youtube.com/watch?v=wCIYViPd4SU&t=960s) degradation. It's just there's too much

[16:03](https://www.youtube.com/watch?v=wCIYViPd4SU&t=963s) volatility in that that we don't need to

[16:06](https://www.youtube.com/watch?v=wCIYViPd4SU&t=966s) risk as the openweight models kind of

[16:08](https://www.youtube.com/watch?v=wCIYViPd4SU&t=968s) become more advanced and sophisticated.

[16:22](https://www.youtube.com/watch?v=wCIYViPd4SU&t=982s) request.

[16:31](https://www.youtube.com/watch?v=wCIYViPd4SU&t=991s) >> Yeah. So as you can see the header is

[16:33](https://www.youtube.com/watch?v=wCIYViPd4SU&t=993s) not purely differentiating in itself.

[16:36](https://www.youtube.com/watch?v=wCIYViPd4SU&t=996s) Someone someone could certainly populate

[16:38](https://www.youtube.com/watch?v=wCIYViPd4SU&t=998s) that, but the actor the identity itself

[16:40](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1000s) will not be me, right? So some someone

[16:43](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1003s) could I guess write in that they're

[16:46](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1006s) using some agent, but the core previous

[16:49](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1009s) identity itself is not mimickable, not

[16:52](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1012s) like actually interceptable, right? So

[16:54](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1014s) we still we have both we have both the

[16:57](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1017s) originating identity and that you know

[16:59](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1019s) all of your identity ecosystems and

[17:01](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1021s) chains to ensure that but also the

[17:03](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1023s) header. part of the header.

[17:05](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1025s) >> Yeah, that that that is separate. The

[17:06](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1026s) header is just XSLm agent and then you

[17:09](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1029s) still have some way you you need some

[17:12](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1032s) way to actually determine the identity

[17:13](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1033s) of who's coming.

[17:26](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1046s) Yeah, I you know gen generally all of

[17:29](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1049s) our RPC in some way has an initial entry

[17:32](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1052s) point that is like

[17:34](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1054s) populatable with that header and then

[17:35](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1055s) once it actually goes downstream you

[17:37](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1057s) know you make sure that same with trace

[17:39](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1059s) ids is part of the span internally

[17:41](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1061s) within the So

[17:45](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1065s) >> can you clarify how the use of Google

[17:48](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1068s) index addresses the prompt injection

[17:51](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1071s) issue?

[17:52](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1072s) >> Yeah. So the core things about this

[17:54](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1074s) index is not only is it a cached index,

[17:57](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1077s) it is it has a lot of other controls and

[18:00](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1080s) safety guarantees around it. It is

[18:01](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1081s) specifically made for these curated

[18:04](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1084s) financial like um highly regulated

[18:06](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1086s) industries. So they themselves are doing

[18:08](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1088s) some of their own curation on top of it.

[18:10](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1090s) Now certainly I think that creation

[18:12](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1092s) could fail. It's probably done using Gen

[18:14](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1094s) AI but the prompt injection risk is much

[18:18](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1098s) far reduced because everything still

[18:20](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1100s) remains internal.

[18:24](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1104s) >> Yep.

[18:33](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1113s) >> Do you mean how they're being used?

[18:38](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1118s) >> Yeah. I I think it's critical um in the

[18:40](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1120s) sense that that behavioral data is

[18:42](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1122s) something we can further configure based

[18:44](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1124s) on right like that we we do try to

[18:48](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1128s) ensure that not everyone at the firm can

[18:50](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1130s) see what your agents are doing right

[18:52](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1132s) like there's stuff certainly work-wise

[18:54](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1134s) but also more sensitive information that

[18:56](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1136s) might be privileged to you. So your

[18:58](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1138s) session data is kind of localized. Now

[19:00](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1140s) that behavioral data in the session data

[19:02](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1142s) is very powerful because it can define

[19:04](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1144s) additional configuration that can be

[19:06](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1146s) applied to these agents for the purposes

[19:08](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1148s) of making the user experience better. So

[19:10](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1150s) we we try to leverage that to figure out

[19:12](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1152s) what to configure further not just based

[19:15](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1155s) on someone's like hierarchical persona

[19:17](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1157s) but actually based on their usage to

[19:19](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1159s) make sure that their experience

[19:20](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1160s) continues to improve actually based on

[19:22](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1162s) what they're doing.

[19:26](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1166s) Uh we're almost out of time. me and my

[19:29](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1169s) co sorry I'll take the last question

[19:33](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1173s) you're saying you have a process for

[19:36](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1176s) letting individuals create their own

[19:38](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1178s) >> yep

[19:40](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1180s) I mean how do you go about like anybody

[19:44](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1184s) there

[19:48](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1188s) is a process for like agents across the

[19:51](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1191s) company

[19:54](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1194s) >> yeah uh for building our own agents you

[19:57](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1197s) know we we use some of the existing

[19:59](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1199s) frameworks for agent building. Obviously

[20:00](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1200s) all the genai harnesses are very good at

[20:03](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1203s) using those frameworks to build agents.

[20:04](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1204s) So you have a lot of agents

[20:05](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1205s) proliferating based on that. In terms of

[20:08](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1208s) provision, everything is already

[20:09](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1209s) provision. All this is every single user

[20:11](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1211s) at the firm has all the necessary

[20:13](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1213s) infrastructure in place. So that's not

[20:16](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1216s) really a worry. They can build an agent,

[20:18](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1218s) deploy it as necessary into their

[20:19](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1219s) namespace running as their identity. the

[20:21](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1221s) the aspect of how do agents then become

[20:24](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1224s) like a universal companywide or larger

[20:27](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1227s) beyond a individual users uh agent you

[20:31](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1231s) know goes through your standard kind of

[20:33](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1233s) mechanisms right like hey is there going

[20:35](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1235s) to be proper production support is there

[20:37](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1237s) the right security it's like any

[20:38](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1238s) application you might develop

[20:41](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1241s) uh yeah so me and my colleagues will

[20:42](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1242s) stick around here if anyone wants to

[20:44](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1244s) talk further you know I guess if you're

[20:46](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1246s) sticking around I can also take more

[20:48](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1248s) questions but thanks for coming to this

[20:51](https://www.youtube.com/watch?v=wCIYViPd4SU&t=1251s) >> [applause]
