# Give the Agent a Budget, Not a Token — Sachin Malhotra, Anthropic

Sachin Malhotra, Anthropic

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/rbjWzZK2LU0-give-agent-budget-not-token) · [Video](https://www.youtube.com/watch?v=rbjWzZK2LU0)

## Give the Agent a Budget, Not a Token

Sachin Malhotra explains how replenishing limits, asymmetric permissions, aggregate monitoring, recovery tests, and infrastructure-stamped identity can give production agents useful autonomy without giving one bad loop unlimited consequences.

### The cleanup that matched everything

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

Sachin Malhotra works on Anthropic’s CI team, which maintains systems including test quarantining, merge automation, autoscaling, and merge queues. That production setting is the backdrop for a warning about the familiar agent demo: give a model a “god-token” and a tool list, watch it build and deploy something in seconds, then mistake the successful demonstration for a safe operating model.

One cleanup agent showed what happens next. It listed workloads it believed were no longer useful and prepared to delete them. One pipeline stage then evaluated to nothing, causing its filter to disappear. The resulting selector matched every workload rather than the intended subset. About 200 workloads disappeared in 90 seconds, affecting work associated with roughly 20 engineers.

The agent was not malicious; it was trying to tidy up after itself. Some deleted workloads were long-running training jobs, and Malhotra says some may not have been checkpointed. That uncertainty matters because it leaves the amount of unrecoverable work unmeasured, but the immediate failure is clear: a small selection error could trigger destructive writes at machine speed.

The agent also did nothing its human operator was technically forbidden to do because it used his token. The dangerous step was transferring that authority, unchanged and unbounded, to an unattended system that never tires and can remain confidently wrong. Human onboarding already addresses a similar problem: new engineers receive useful access, escalation paths, and structural barriers around catastrophic actions rather than constant keystroke supervision.

### Replace boolean permission with a multidimensional budget

[4:23](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=263s)

The obvious response—remove delete permission—creates a different failure. Eventually the agent encounters a legitimate deletion and a human returns to pressing Enter on its behalf. A token scope is boolean: the caller either has an operation or does not. Too narrow, and the agent cannot finish useful work; too broad, and a selection bug can become a postmortem.

A budget asks four richer questions: how much can the agent do, how quickly can it do it, what can it undo itself, and who will notice its actions? Malhotra turns those dimensions into three enforceable primitives—asymmetric verbs, rate limits, and tripwires—plus an undo test used to size the other controls.

The first primitive classifies verbs by how failure becomes visible. An incorrect **unskip test** action makes CI turn red, so the error announces itself and a human can cheaply restore the skip. An incorrect **skip test** action can leave every check green while allowing a real bug into production. Paging an on-call unnecessarily is likewise noisy and correctable. These operations can look symmetrical in an API while carrying very different failure modes.

That yields an operational rule: agents may perform verbs that fail loudly on a dashboard, while verbs that fail quietly require a human. In the test-quarantine service, the agent may re-enable tests because a wrong decision produces visible failures. Skipping remains a break-glass operation for the on-call, with an audit trail. A proxy—not the agent—stamps the caller identity on both operations, so the agent never controls its own provenance.

What does this asymmetry make visible? The comparison below separates API-level similarity from operational consequences: the safer autonomous verb is the one whose incorrect result creates an observable signal and a cheap correction path.

The same resource, opposite failure visibility
Skipping and unskipping both modify test state, but only the wrong unskip reliably announces itself through red CI.
- Agent unskips a test — If wrong, builds turn red and a human can restore the skip cheaply.
- Agent skips a test — If wrong, checks can stay green while a bug proceeds toward production.
- Autonomous access — Suitable for the operation whose failure is visible and reversible.
- Human second key — Retained for the silent, break-glass operation.
- Agent unskips a test → Autonomous access (fails loudly)
- Agent skips a test → Human second key (fails quietly)

### Put a ceiling on every write—and let it refill

[8:27](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=507s)

Rate limits provide the most concrete version of a budget: a ceiling that refills. Each caller receives a limited number of disruptive actions per time window. Requests inside the budget need no approval. Once the caller crosses the line, the next request is rejected with the relevant count; after time passes, capacity returns automatically.

This preserves autonomy without allowing one runaway loop to grow without bound. Every write gets a limit, but the limit reflects context. Deleting workloads in the caller’s own namespace may receive a larger allowance than modifying a shared namespace. The control changes the maximum damage rate rather than removing the operation entirely.

After the deletion incident, a neighboring team built an admission webhook that caps deletes at a fixed number per hour, resource kind, and namespace. A bypass exists for exceptional human operations, but it refuses to activate inside an agent session. The agent can only ask a human to run the command. This keeps routine cleanup self-service, reserves the override for a separate actor, and avoids permanent access-expansion tickets because the ordinary allowance replenishes itself.

### Use tripwires to learn from aggregate behavior

[10:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=605s)

Allowlists predict in advance what an agent will need. That prediction is static and can become stale before the team has observed much real behavior. For cheap actions, a tripwire takes the opposite approach: let the action occur within enforced limits, record it with a trusted actor identity, and watch aggregate behavior for anomalies.

Rate limits and tripwires therefore solve different problems. The rate limit is enforcement: it caps the pace of writes. The tripwire is detection after the fact: it reveals what the permitted activity added up to. Malhotra calls it a smoke detector rather than a lock, and stresses that a detector nobody sees is useless; crossing the threshold must notify someone who can respond.

A CI investigation agent supplies the concrete example. The team tracked the number of investigation threads it opened per hour for test-job failures. One morning that count rose well above baseline and paged the on-call. Each thread looked reasonable by itself: a job had failed, so the agent opened an investigation. In aggregate, dozens of jobs shared the same error signature because one infrastructure failure was producing the same symptom everywhere.

The response was a small context change rather than a new orchestration system: before opening separate threads, correlate failures across jobs and look for a shared cause. When the pattern recurred, the agent followed that guidance. The observable change was fewer redundant investigations because the agent first grouped matching failures, inferred a common infrastructure problem, and then avoided treating every affected job as an independent incident.

### Size autonomy with the undo test

[12:13](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=733s)

The undo test is not another code-level guard. It asks two questions when choosing the other controls: can the agent restore the previous state by itself, and how bad is the impact if it gets the operation wrong? Asymmetric verbs ask whether failure becomes visible; the undo test asks whether recovery is possible.

If the agent can roll back its change and the possible blast radius is acceptable, the system can log the operation and let it proceed. If either condition fails, the operation needs a second key held by someone else, plus an audit record explaining what happened and why that second actor approved it.

Feature flags show how this can work outside CI. In canary traffic—staging and internal dogfooding—the agent may move a feature from zero to 100 percent, observe filed bugs, and turn it back off. It cannot promote the feature into production. It may propose promotion after canary testing, but a separately scoped production key supplies the second key; no novel authentication system is required.

Day to day, the agent can own the canary rollout loop and ask clarifying questions about the intended audience while each action carries the agent’s identity rather than the human requester’s. The controls compose around distinct questions: asymmetric verbs determine what it may touch, rate limits determine how often, tripwires report what the activity became, and the undo test sets the size of those permissions and limits.

Applied to the opening deletion, a rate limit would have stopped the loop after a few tens of workloads rather than roughly 200. The undo test then observes that a running job in another engineer’s namespace cannot simply be undeleted. Deletion beyond the cap therefore belongs behind a human-held second key. Not every write needs every safeguard; the relevant mix follows from visibility, frequency, reversibility, and impact.

This resembles an onboarding checklist because it answers the same operational questions: what may a new actor touch, how much room does it receive, who signs off on exceptional operations, and how does the team learn whether the arrangement works? The difference is that the checklist must now govern an actor operating continuously at software speed.

### Let text explain intent and infrastructure enforce the boundary

[15:31](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=931s)

The policy lives in two places. Prompts, context files, and Markdown explain intent: why an action is risky, what pattern should be preferred, and how the agent should reason about it. These instructions are cheap to change and can incorporate lessons such as correlating similar failures before opening investigations.

Malhotra reports that one such sentence in a Markdown file works about 80 percent of the time. Text also accumulates and needs pruning, and ultimately remains advice rather than enforcement. The proxy supplies the hard boundary: it sees a delete or a crossed budget and returns `403`. It counts, compares, allows, or denies without needing to understand the agent’s explanation.

The two layers compensate for each other’s limits. Text can explain the “why” but cannot guarantee compliance. Infrastructure cannot explain intent, but it is narrow and deterministic, and prompt injection cannot persuade it to ignore a numeric limit. Text shapes what the agent tries to do; infrastructure bounds how wrong execution can go.

### Identity must come from outside the request

[16:43](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1003s)

Every agent session runs beside a proxy. The agent first reads its context files, then sends every outbound call through that proxy. The proxy stamps the action with an identity it already knows. When an agent launches Kubernetes jobs, the cluster writes that identity onto the job as a label, and child jobs inherit it.

Ownership checks, quotas, rate limits, approvals, and tripwires can all key off the same inherited stamp. The proxy does not need to follow every descendant operation itself; identity propagates through the infrastructure. Most importantly, the agent never gets to edit the value on which its safeguards depend.

What does the topology need to guarantee? The diagram below shows why attribution must enter through the proxy and then flow with created resources. One trusted stamp gives downstream systems a stable key for every budget and alert, even when work branches into child jobs.

Trusted identity propagates through agent-created work
The proxy assigns identity once; downstream resources inherit it, and safeguards consistently read the same infrastructure-controlled stamp.
- Agent session — Reads context and requests outbound actions but cannot choose its trusted identity.
- Session proxy — Holds real credentials and stamps each call with the known agent and session identity.
- Kubernetes cluster — Writes the trusted stamp onto the launched job as a label.
- Child jobs — Inherit the same identity label from their parent work.
- Budgets and safeguards — Ownership, quotas, rate limits, approvals, and tripwires all key off the stamp.
- Agent session → Session proxy (all outbound calls)
- Session proxy → Kubernetes cluster (trusted identity stamp)
- Kubernetes cluster → Child jobs (identity inheritance)
- Kubernetes cluster → Budgets and safeguards (label supplies policy key)
- Child jobs → Budgets and safeguards (same inherited policy key)

### A self-asserted identity turns limits into suggestions

[17:43](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1063s)

If the caller may set its own identity header, every budget can be reset by changing the name. After exhausting the allowance for “Sachin,” an agent can present itself as “Sachin two” and receive a fresh budget. The system may appear to have a rate limit, but the caller can route around it, making the control a suggestion.

With the proxy in the path, the agent never declares who it is. The proxy holds the real credentials and stamps calls from infrastructure-known identity. It can also attach a per-session ID, allowing operators to distinguish concurrent sessions and identify which one is overreacting or failing to act as intended.

The final operating model is compact: give agents verbs that fail loudly; keep humans on verbs that fail quietly; put a replenishing ceiling on every write; monitor aggregate behavior; use the undo test to choose caps and second keys; and fix inexpensive behavioral mistakes with text where possible. All of those controls depend on identity supplied by infrastructure rather than claimed in the request. Get that rule right, Malhotra concludes, and the remaining work is tuning.

## Key takeaways

- Replace boolean agent permissions with budgets that account for quantity, speed, reversibility, and observation.
- Give agents operations whose mistakes fail loudly and remain cheap to correct; require humans for quiet, break-glass actions.
- Rate-limit every write, vary the allowance by resource context, and keep exceptional bypasses outside agent sessions.
- Watch aggregate behavior with visible tripwires: individually reasonable actions can collectively reveal duplication or a shared underlying failure.
- Apply the undo test before granting autonomy. Irreversible or unacceptably damaging operations need a second key held by another actor.
- Use text to teach intent and deterministic infrastructure to enforce hard limits; neither layer replaces the other.
- Stamp agent and session identity in a trusted proxy. If callers can claim their own identity, they can reset identity-keyed budgets by renaming themselves.

## 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 and authorization problem into delegated identities, signed delegation chains, scoped tokens, and auditability.
- [It's 10pm. Do You Know Where Your Agents Are?](https://ai.engineer/talks/I3znWC3MEXM-its-10pm-do-you-know-where) — Examines how identity and policy checks can issue narrowly scoped credentials for individual agent tool calls.
- [3 ingredients for building reliable enterprise agents](https://ai.engineer/talks/kTnfJszFxCg-3-ingredients-building-reliable-enterprise-agents) — Develops the complementary ideas of reversible actions, human correction, and combining autonomy with deterministic workflows.

## Slides

### Give the agent a budget, not a token

Sachin Malhotra introduces a talk on letting coding agents work against real infrastructure without writing the postmortem.

[0:18](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=18s) [Title slide introducing a talk about coding agents working against real infrastructure.](https://assets.ai.engineer/sites/aiecode2025/sha256/ae1e0dd18a15b79d2390cabfccb23f78f3f3c3b4c77ff01d6b7eb1e3980fc70b.webp)

Give the agent a budget, not a token

Letting coding agents do real work against real infrastructure, without writing the postmortem.

Sachin Malhotra · Anthropic
AI Engineer World’s Fair 2026

### Sachin Malhotra

Sachin Malhotra works on Anthropic’s CI team, which manages test machinery including merge automation and CI autoscaling. His introduction pairs his work with a mountain photo and his interest in coffee.

[0:22](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=22s) [Speaker introduction with a mountain photo and details about Sachin Malhotra’s work and interests.](https://assets.ai.engineer/sites/aiecode2025/sha256/c9b120a3c4c78f96ed2ea2d6467a6e5e9ed1bd9b324ef19cc63dd2101aa70561.webp)

Sachin Malhotra
CI team · Anthropic

10 months at Anthropic
Etsy and Microsoft before that
Seattle, WA

Outside work: dialing in my coffee setup and getting up mountains

### Here's a token. Here's a tool list. Watch it go.

A demo gives an agent a powerful token and tools to build and deploy a coffee site in three seconds. Malhotra’s focus is what happens when the agent goes to production.

[0:52](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=52s) [Slide describes giving an agent a token and tools, then shipping the result to production; a terminal appears at right.](https://assets.ai.engineer/sites/aiecode2025/sha256/9d7afd4a976f03085ee11b28439c71b878a60932aac677730d6d9b56245b75bc.webp)

Here's a token.
Here's a tool list.
Watch it go.

...then someone ships it to production.

$ ag

### Workload deletion incident

An agent cleaning up workloads ran a command with an empty prefix, causing the filter to pass everything. It deleted about 200 workloads and affected about 20 engineers in 90 seconds.

[1:31](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=91s) [Terminal output shows deleted workloads; a callout says an empty prefix caused the filter to drop out.](https://assets.ai.engineer/sites/aiecode2025/sha256/008250fed8c74b23b059761b3e2c593dec01297c90b7a609c35fc3ed72f6b3fc.webp)

$ kubectl get sts -A \
    | grep -v "^${PREFIX}-" \
    | xargs kubectl delete

statefulset.apps "worker-7f3a" deleted
statefulset.apps "worker-b219" deleted
statefulset.apps "worker-04c1" deleted
statefulset.apps "worker-11e8" deleted
statefulset.apps "worker-02d4" deleted
statefulset.apps "worker-a4f0" deleted
statefulset.apps "worker-019b" deleted
… and a couple hundred more

$PREFIX was empty
The filter dropped out and the selector matched everything.

### Incident impact

An agent tidying up deleted about 200 workloads affecting roughly 20 engineers in 90 seconds. Some were long-running training jobs.

[1:54](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=114s) [Approximately 200 workloads and 20 engineers affected in 90 seconds.](https://assets.ai.engineer/sites/aiecode2025/sha256/4fa2bd00072bbd615c2c016edf34fa83c81a42a4b0dc90270074232efdb62e5a.webp)

~200
workloads

20
engineers affected

90s
start to finish

### Three primitives and a lens

Malhotra introduces three primitives—asymmetric verbs, rate limits, and tripwires over allow-lists—and uses the undo test to assess them: can it be undone?

[2:35](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=155s) [Agenda lists asymmetric verbs, rate limits, tripwires over allow-lists, and the undo test.](https://assets.ai.engineer/sites/aiecode2025/sha256/265c0349353abeea077b9dbe0fcab27933543e9e9f1403b88a0b7ec4ed6cc732.webp)

Three primitives and a lens

1 Asymmetric verbs
2 Rate limits
3 Tripwires over allow-lists

the lens
The undo test — can it be undone?

then → how they compose → the one rule underneath → take home

### Onboarding a junior engineer

Malhotra compares agent policy to onboarding a junior engineer: provide an escalation path and keep catastrophic actions out of reach without watching every keystroke.

[3:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=185s) [You already solved this the day you onboarded your first junior engineer.](https://assets.ai.engineer/sites/aiecode2025/sha256/9186a20bf5386093473c6549308ba29e7aabd4f1fca54ec8ad25c84c497e06e7.webp)

You already solved this the day you onboarded your first junior engineer.

### Replace the boolean with a shape

A token grants or denies a scope. A budget shapes how much and how fast an agent can act, what it can undo, and who is watching.

[4:21](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=261s) [A token is presented as a boolean; a budget includes amount, speed, reversibility, and oversight.](https://assets.ai.engineer/sites/aiecode2025/sha256/af24f70ea45b99ba350d32a143cbb71986f360c31a9094786d8d5a7242244e2a.webp)

Replace the boolean with a shape

Token
A token is a boolean. You have it or you don't.

Budget
A budget has a shape.
• how much
• how fast
• what you can undo
• who’s watching

### Asymmetric verbs

An agent can unskip a test or page on its own; skip and silence need a human. A mistaken unskip can turn CI red, while a mistaken skip can leave a bug behind green checks.

[5:46](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=346s) [Unskip and page are actions an agent can take alone; skip and silence require a human.](https://assets.ai.engineer/sites/aiecode2025/sha256/41d8cf954572a9b7cc2e4d8e2ef238ee2c2d2b2b53892839355b6bfb4826471a.webp)

Primitive 1
Asymmetric verbs

Fails loud · agent acts alone
unskip
page

skip
silence
Fails silent · needs a human

### Turning tests on and off

An agent can re-enable a quarantined test; a bad call turns CI red. Skipping a test requires a human and leaves an audit trail. A proxy stamps the caller’s identity on both actions.

[7:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=432s) [A CI workflow shows an agent unskipping a test and a human-authorized skip recorded in an audit trail.](https://assets.ai.engineer/sites/aiecode2025/sha256/404dbddc6078a3c424801e60c7af8bef4157e53630f022966a11d49be8dd053c.webp)

Primitive 1 · Asymmetric verbs

The agent can turn a test back on by itself. Turning one off takes a human.

unskip
agent · fails loud (CI goes red)

PR builds
CI runs tests
minus the quarantine list
merge
proxy
stamps
quarantine
quarantine list
+ audit trail

skip
breakglass · human + audit row

### Rate limits

Each caller gets a budget of disruptive actions per time window. Requests beyond the limit bounce until it refills; the budget size varies with blast radius.

[8:25](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=505s) [A rate-limit budget refills over time; its size scales with blast radius.](https://assets.ai.engineer/sites/aiecode2025/sha256/9e98a5c2c74885fcef0a9cb59777b1e1d1a05043247592047cee3b7cf2e11030.webp)

Primitive 2
Rate limits

(actor, kind, namespace)
refills with time
spent
N per window

every write has a rate limit · size scales with blast radius

### The bypass flag refuses inside an agent session

An admission webhook caps deletes per hour, resource kind, and namespace. The bypass flag refuses inside an agent session and asks a human to run the command instead.

[9:19](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=559s) [An admission webhook limits agent deletes; bypass is refused in the agent session and left for a human to run.](https://assets.ai.engineer/sites/aiecode2025/sha256/f78ff9c04461bc8c845443a458622fb2d91cbbd30b63ba8f0c33acea0351a0fd.webp)

Primitive 2 · Rate limits
The bypass flag refuses inside an agent session

agent gets the rate limit · human keeps the override

agent
delete sts/x

admission webhook
N/hr · own = wide

cluster

--bypass
refused
in agent session

Run this yourself:
$ delete sts/x --bypass

### Tripwires over allow-lists

An allow-list guesses what an agent needs upfront. For cheap actions, the tripwire loop records who acted, reviews patterns, and patches the prompt using what happened.

[10:03](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=603s) [A static allow-list is contrasted with a tripwire feedback loop that records actions, reviews patterns, and patches the prompt.](https://assets.ai.engineer/sites/aiecode2025/sha256/3a087bb41673f5a4c59aef2f6fec72fb8075ee9c170e932703a9e3eb47130ede.webp)

Primitive 3
Tripwires over allow-lists

allow-list
static · guesses up front

acts
tripwire records
actor:agent
review pattern
patch prompt

tripwire
a feedback loop · gets better each round

### The fix is a sentence, not a deploy

A spike in investigation threads per hour for a test-job failure triggers a tripwire. The fix tells the agent to correlate matching errors across jobs and open one investigation.

[11:02](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=662s) [A spike in investigation threads triggers a tripwire and an agent-context instruction to correlate matching errors across jobs.](https://assets.ai.engineer/sites/aiecode2025/sha256/ec70538d271ceac7df7055090607e3632e6ef83816315f3b65d2963b9598894a.webp)

Primitive 3 · Tripwires over allow-lists
The fix is a sentence, not a deploy

tripwire fires
baseline
investigation threads / hr · per failure

# agent context
...
+ When the same error fingerprint appears
+ across many jobs, correlate: open one
+ investigation, not one per job.

### The undo test

If the agent can undo its own change and the blast radius is acceptable, log it and let it go. Otherwise, someone else must hold a second key, with an audit record of what happened.

[12:10](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=730s) [A decision tree asks whether the agent can undo an action and whether its blast radius is acceptable; otherwise a second key is needed.](https://assets.ai.engineer/sites/aiecode2025/sha256/0e42ac775e453e9895b76e7dc5e2dbb1feb3f6d920c46355f1ef5bec2b84bcfd.webp)

The lens
The undo test

Can the agent put it back by itself?
How bad is the blast radius if it's wrong?
two questions · same gate

yes · and acceptable
log it · let it go

no · either one
needs a second key

the key is the audit record:
no escalating without a trail

### The agent owns the canary. A human owns the prod gate.

The agent can create, ramp and disable feature flags across staging and dogfood traffic. Promoting a flag to production requires human approval.

[13:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=785s) [The agent controls the staging and dogfood rollout, while promotion to production requires human approval.](https://assets.ai.engineer/sites/aiecode2025/sha256/ceef86848580ada1a36debedb741c041a3bdf830423a88bccddd68f82c6bfd6a.webp)

The lens · Can it be undone?
The agent owns the canary. A human owns the prod gate.

staging · dogfood
agent · full dial
create  enable  ramp  disable
0%  100%

production
tap to approve
promote-to-prod

### What that looks like day to day

Claude clarifies the rollout audience, enables the flag for the dogfood group and tracks bug reports. The speaker says the agent’s actions carry its own identity.

[13:58](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=838s) [A chat shows an agent clarifying the rollout audience, enabling a feature for internal testing, and monitoring feedback.](https://assets.ai.engineer/sites/aiecode2025/sha256/270e269578fc1b59b3df30a867f43018f63d235f09224c97a98469d2285e2978.webp)

The lens · Can it be undone?
What that looks like day to day

smal  10:42 AM
@Claude can you roll out retry-budgeter? own the monitoring + any feedback that comes in

Claude  10:42 AM
on it. just the internal dogfood group, or early-access customers too?

smal  10:43 AM
just dogfood for now

Claude  10:44 AM
enabled for the dogfooding group only. I'll track any bug reports on the asana dashboard and report back.

### It's four questions, not four systems

Asymmetric verbs define what an agent can touch, rate limits govern how often, and tripwires catch what happens afterward. The undo test helps size all three; the relevant checks depend on the action.

[14:25](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=865s) [Three cards cover asymmetric verbs, rate limits, and tripwires; an undo test sizes all three.](https://assets.ai.engineer/sites/aiecode2025/sha256/8568910b650792b7a83eef2ba1bddace5a264edf26a2afc060ff6f6a9a2b67ed.webp)

Composition
It's four questions, not four systems

The same checklist you hand a new engineer on day one: what can they touch · how much rope · how do we know it’s working · who signs off.

Asymmetric verbs
What is it touching?

Rate limits
How often?

Tripwires
What happened after?

the lens
The undo test — sizes all three. Who else needs to know?

### Policy as text

A context file tells agents not to retry load-shed CI jobs and explains why. Written policy is cheap to change and can generalize, but stale guidance can cause wrong behavior and cannot enforce the rule.

[15:29](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=929s) [A context-file example sits beside the benefits and costs of written policy, which shapes intent but does not enforce it.](https://assets.ai.engineer/sites/aiecode2025/sha256/adf15bf5b8299c057a4a160c6bea94cbeb371b9d76dfaa7646228bd25f4411f5.webp)

Policy · layer one
Policy as text

# agent-context.md

## CI retries
Don't retry CI jobs that were
load-shed. The capacity isn't
there, and retrying makes the
backlog worse. Flag it instead.

what it buys you
descriptive · explains why
cheap to change
generalizes to cases you didn't list

what it costs you
you have to garden it
stale docs = wrong behavior
it's advice, not enforcement

Shapes intent. Doesn't enforce.

### Policy as infrastructure

A policy proxy blocks a delete when the resource owner differs from the caller. It enforces the same rule for everyone, but is expensive to change and cannot explain why.

[16:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=965s) [A blocked command illustrates infrastructure policy, with cards describing its enforcement benefits and costs.](https://assets.ai.engineer/sites/aiecode2025/sha256/f8fc60d87cf3125c9bc89a09e83013b0fc165411d9b8d0d297d743a31506a02d.webp)

Policy · layer two
Policy as infrastructure

$ kubectl delete sts -n other-team ...

Error from server (Forbidden):
delete blocked by policy proxy:
resource owner != caller

what it buys you
actually enforces
deterministic · can’t be reasoned around
same rule for every caller

what it costs you
expensive to change
can’t explain why

Text shapes intent. Infrastructure bounds damage. You need both.

### Every safeguard reads the same stamp

Each agent session has a proxy that stamps launches with its identity. The cluster writes that identity as a job label, child jobs inherit it, and safeguards read the same label.

[16:40](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1000s) [A session proxy stamps a launch; a cluster carries the label to child jobs and uses it for safeguards.](https://assets.ai.engineer/sites/aiecode2025/sha256/0275fcea07d2399aafd6e4ade067828d106e85829b6a46f855e6be7b50da7dc1.webp)

Policy · where it lives
Every safeguard reads the same stamp

Sachin’s dev box
agent session A
context.md
agent
proxy
stamps launch

launch
id:agent-A
one proxy per session · not a central box

cluster
cluster writes label
job
id:agent-A
child job
id:agent-A
child job
id:agent-A
child job
id:agent-A
children inherit

safeguards · all keyed on the label
ownership
quota
rate limit
approval
audit
tripwire

The proxy stamps once at the boundary. The infrastructure carries the stamp forward. Every safeguard reads it.

### Why the proxy does the stamping

A separate proxy stamps the agent’s identity. If the agent could choose its own name, it could change it and reset its limits.

[17:41](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1061s) [Section slide explaining that a caller can otherwise claim a different identity.](https://assets.ai.engineer/sites/aiecode2025/sha256/3864c02b361c1972a7141460e0439560abfcaff8e7b6e0366fa041f82135ac62.webp)

Why the proxy
does the stamping

If the caller says who it is, nothing stops it saying something else.

### Why the proxy?

An agent that sets its own identity can change its header and get a fresh delete budget. A proxy stamps the identity itself, so the 50/50 limit still applies and the next delete is denied.

[17:59](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1079s) [A comparison shows how changing a caller-set identity resets a budget, while a proxy-stamped identity preserves the limit.](https://assets.ai.engineer/sites/aiecode2025/sha256/4a9d48b6ca1ceffc5447bcafd094cb9e112269d44f47867fce6c9b5b29586968.webp)

Why the proxy does the stamping
Why the proxy?

agent sets its own identity
X-Agent-Id: sachin sachin-2
deletes: 50/50
deletes: 0/50 (fresh)

proxy stamps it
identity: sachin · session: C
deletes: 50/50 · denied
no header to change — the stamp isn't the agent's to set

A budget the agent can rename its way around isn't a budget.

### Take home

Give agents actions that fail loudly, cap writes with self-refilling limits, and watch aggregate behavior. Use the undo test to size those controls, with identity supplied by infrastructure.

[18:47](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1127s) [Takeaways cover asymmetric verbs, rate limits, tripwires and the undo test, with identity supplied by infrastructure.](https://assets.ai.engineer/sites/aiecode2025/sha256/8619ff1bef86acd6e817cc79638e09ea1999830277a8b4dc88b478f91a15bd4e.webp)

Take home

Asymmetric verbs
Give it the verbs that fail loud. Keep a human on the quiet ones.

Rate limits
A ceiling on every write that refills on its own. Nobody files a ticket.

Tripwires
Watch the aggregate, not the calls. Fix what you find with a sentence.

the lens
The undo test
Can it put it back, and is the blast radius OK? That's how you size the other three.

underneath all of it
Identity comes from the infrastructure, not the request.

### AI Engineer World's Fair

[19:47](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1187s) [AI Engineer World's Fair logo in white on a black background, with the event website below.](https://assets.ai.engineer/sites/aiecode2025/sha256/b1707be1b58539c8aec39fa1e0a8693ea4a8d30993e6ce3e157653309baf65c6.webp)

AI Engineer
World’s Fair

HTTPS://AI.ENGINEER

## Full transcript

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

[0:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=12s) Hello. All right. Uh, let's get started.

[0:16](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=16s) So, um, well, welcome to the talk. Give

[0:20](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=20s) the agent a budget, not a not a token.

[0:23](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=23s) Um, quick intro about me. My name is

[0:25](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=25s) Sachin. Um, I'm an engineer on the CI

[0:27](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=27s) team at Entropic. Uh we basically build

[0:29](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=29s) and manage all of the test machinery for

[0:31](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=31s) all the code that people write. Uh so

[0:34](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=34s) everything from test quarantining to

[0:35](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=35s) merge automation to CI autoscaling to

[0:38](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=38s) merge cues, everything and anything in

[0:39](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=39s) between. Um it's it's basically the

[0:41](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=41s) plumbing that allows a few thousand

[0:42](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=42s) engineers every day to ship code safely.

[0:45](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=45s) Uh I've been at the company for a little

[0:46](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=46s) over 10 months. I'm based out of

[0:47](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=47s) Seattle. Um and outside of work, I love

[0:50](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=50s) dialing my espressos and climbing some

[0:51](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=51s) crazy mountains.

[0:54](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=54s) So a lot of cool agent demos they they

[0:56](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=56s) start with the same way really. So

[0:58](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=58s) someone gives an agent a god token um

[1:01](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=61s) and gives it an access to some sort of

[1:02](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=62s) tool list and just watch as it goes. So

[1:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=65s) and it does go like in in this

[1:06](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=66s) particular example it it'll spin up like

[1:08](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=68s) a cute little coffee website. It'll

[1:10](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=70s) build all the pages, deploy them, uh

[1:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=72s) bring it up live and it's done in 3

[1:13](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=73s) seconds. Uh people will nod people will

[1:16](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=76s) clap and someone will ship it into

[1:18](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=78s) production. And this this talk is

[1:20](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=80s) basically about what happens after that

[1:22](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=82s) after the demo ships once the agent is

[1:24](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=84s) starting to do some like real work in

[1:26](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=86s) production. [snorts]

[1:28](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=88s) So here's what after looked like in in

[1:31](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=91s) our one of our scenarios. So what you're

[1:33](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=93s) looking at is like a real command. Um

[1:34](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=94s) the agent was trying to clean up after

[1:36](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=96s) itself. Um it it was basically listing a

[1:38](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=98s) bunch of workloads that were no longer

[1:40](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=100s) interesting or useful to itself. Um and

[1:42](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=102s) then it found them and deleted them. Now

[1:45](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=105s) that's that's completely reasonable

[1:46](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=106s) except one stage in the pipeline

[1:49](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=109s) basically evaluated to nothing and the

[1:51](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=111s) filter dropped out and now the selector

[1:53](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=113s) matched everything.

[1:56](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=116s) So you can see it took out about 200

[1:58](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=118s) workloads uh which ended up impacting

[2:00](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=120s) about 20 engineers worth of stuff and

[2:02](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=122s) all of that was gone in 90 seconds.

[2:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=125s) Nobody was being malicious in this case

[2:07](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=127s) like the agent genuinely thought it was

[2:09](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=129s) tidying up after itself. uh some of

[2:11](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=131s) these workloads were long running

[2:13](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=133s) training jobs and stuff. Maybe some of

[2:15](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=135s) these were not even checkpointed and it

[2:17](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=137s) was just like hours of progress that was

[2:18](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=138s) gone poof in like 90 seconds and stuff,

[2:21](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=141s) right? Um the the problem in in this

[2:24](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=144s) case is that this idea of like here's a

[2:27](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=147s) token and here's a tool list that is

[2:29](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=149s) just like not enough like it just

[2:31](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=151s) doesn't scale when the agent is starting

[2:32](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=152s) to do some some like real work in

[2:34](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=154s) production.

[2:37](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=157s) >> So here's just a brief summary of like

[2:39](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=159s) what we're going to talk about today. Uh

[2:40](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=160s) I'm going to walk through three

[2:42](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=162s) primitives um and asymmetric verbs. We

[2:45](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=165s) we're going to look at some like rate

[2:47](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=167s) limits. We're going to look at this idea

[2:49](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=169s) of like trip wires over allow lists. And

[2:51](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=171s) then I'm going to talk about this one

[2:52](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=172s) lens that which I call the undo test

[2:55](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=175s) that you can sort of use to size up the

[2:57](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=177s) other three primitives. Uh so three

[2:59](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=179s) things that you basically enforce and

[3:01](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=181s) then one question you sort of ask about

[3:02](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=182s) all of them.

[3:06](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=186s) So here's basically what bugged me uh

[3:09](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=189s) after the cleanup was done for the

[3:10](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=190s) incident that I was just showing you. Uh

[3:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=192s) the the agent technically hadn't done

[3:14](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=194s) anything that I couldn't have done. Uh

[3:16](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=196s) it was using my token after all. The the

[3:19](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=199s) failure wasn't the model itself. The

[3:20](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=200s) failure was that I was giving the agent

[3:22](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=202s) unbounded amount of power to do

[3:24](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=204s) something that I wasn't watching super

[3:26](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=206s) intently. Um and it was we've basically

[3:30](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=210s) solved this the same kind of problem

[3:32](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=212s) except not for agents but like the first

[3:34](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=214s) time you onboarded like a junior

[3:35](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=215s) engineer on onto your own teams, right?

[3:37](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=217s) So just think about it like we don't we

[3:39](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=219s) don't basically sit around watching um

[3:41](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=221s) every engineer or new boarded person

[3:43](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=223s) just like type out every keystroke on

[3:46](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=226s) their keyboard, right? Like we're not

[3:47](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=227s) behind their chairs just watching

[3:48](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=228s) everything that they're doing. Uh there

[3:50](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=230s) is always a path on whenever a new

[3:52](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=232s) engineer wants to ask for something. Um

[3:53](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=233s) there is always an escalation path. uh

[3:56](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=236s) the catastrophic stuff is just

[3:58](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=238s) structurally out of reach for them. So

[4:00](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=240s) the the other side of the coin is that

[4:02](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=242s) the agents are very different. They they

[4:04](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=244s) never get tired. They never sleep. And

[4:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=245s) every so often they're just like very

[4:07](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=247s) confidently wrong. Um and if I'm being

[4:09](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=249s) honest, that's that's maybe most of us

[4:10](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=250s) on the first month of our jobs anyways.

[4:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=252s) And so what what we're going to talk

[4:14](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=254s) about in a little bit in is just this

[4:17](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=257s) idea of like your onboarding checklist,

[4:19](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=259s) but written down as policy for for

[4:20](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=260s) agents.

[4:23](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=263s) So that and that brings me to the word

[4:25](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=265s) in the title of my my talk here is that

[4:27](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=267s) the the the standard fix for an incident

[4:30](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=270s) like that is basically that you narrow

[4:32](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=272s) the token scope, right? Like you just

[4:34](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=274s) take the deletes away effectively. You

[4:36](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=276s) would technically never do that for like

[4:38](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=278s) a new hire, right? Like you would you

[4:39](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=279s) wouldn't take the whole verb away from

[4:41](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=281s) them. And it also doesn't work for an

[4:43](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=283s) agent either. Maybe it works for about a

[4:45](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=285s) week, maybe two, but then you eventually

[4:47](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=287s) end up in a situation where the agent is

[4:49](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=289s) genuinely trying to delete something

[4:50](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=290s) that it feels like is just not in the

[4:52](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=292s) infrastructure and you will just be

[4:55](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=295s) there sitting and pressing enter by hand

[4:57](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=297s) all over again. The the core concept

[5:00](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=300s) with a token that I feel like is wrong

[5:02](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=302s) is that a token is a boolean. It's just

[5:03](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=303s) a yes or no. It's a static list of

[5:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=305s) scopes. Um you either have it or you

[5:08](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=308s) don't have it. So if the token list is

[5:10](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=310s) too tight, then your agent is

[5:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=312s) effectively useless. If the token list

[5:14](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=314s) is too wide, then you're maybe writing

[5:16](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=316s) writing like a postmortm. A budget is a

[5:19](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=319s) very different shape. A budget is is um

[5:22](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=322s) not just like one number. It just has

[5:23](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=323s) like four different four different

[5:25](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=325s) dimensions, right? How much can the

[5:27](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=327s) agent do? Uh how fast can it do it? What

[5:30](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=330s) can it undo on its own? And then who's

[5:32](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=332s) noticing while it's actually taking

[5:33](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=333s) those actions? And that's roughly the

[5:36](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=336s) umbrella for like my four primitives. Uh

[5:37](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=337s) is that each of the things that follow,

[5:39](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=339s) they're basically being um one of the

[5:41](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=341s) things along these dimensions. and

[5:43](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=343s) they're going to replace a yes or no

[5:44](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=344s) question with a budget.

[5:47](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=347s) So, I'm going to start off with this

[5:48](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=348s) first verb which I call asymmetric

[5:50](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=350s) verbs. Uh, and by verbs I simply means

[5:53](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=353s) operations or actions that an agent can

[5:55](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=355s) take. So, like it could be API calls, it

[5:56](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=356s) could be uh CLI commands, it could be

[5:58](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=358s) really anything. And they're asymmetric

[6:01](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=361s) because the same sized action even

[6:03](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=363s) though it looks same size, they're they

[6:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=365s) can have very different blast radius in

[6:07](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=367s) actuality depending on which direction

[6:08](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=368s) it goes. So the the core point is that

[6:11](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=371s) you need to stop thinking about

[6:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=372s) resources for a second and think about

[6:14](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=374s) verbs. So specifically think about what

[6:17](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=377s) happens when one of the verbs goes

[6:19](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=379s) wrong. So some verbs they fail out loud.

[6:22](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=382s) So in this particular example, let's say

[6:23](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=383s) if an agent decides to unskip a test and

[6:26](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=386s) say it's the wrong call, the worst that

[6:28](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=388s) would happen is CI would go red uh for a

[6:30](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=390s) bunch of people. Um same with paging.

[6:32](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=392s) Like if an agent decides to page a human

[6:34](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=394s) and if it's the wrong call, the worst

[6:36](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=396s) that's happening is that it's a nuisance

[6:38](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=398s) for the on call. But there's always a

[6:39](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=399s) human to correct it. There are other

[6:42](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=402s) verbs that fail silently, right? So if

[6:43](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=403s) the agent decides to skip a test uh due

[6:46](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=406s) to whatever reason, it shouldn't have.

[6:48](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=408s) Nothing technically turns red. A real

[6:50](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=410s) bug can actually walk into production

[6:52](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=412s) with green checks and nobody would

[6:54](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=414s) notice it until much later. So unskip

[6:56](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=416s) and skip in this example, they're

[6:58](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=418s) effectively the they're the same kind of

[7:00](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=420s) action, but the difference is which of

[7:02](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=422s) the failures would show up on a

[7:03](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=423s) dashboard and which one wouldn't. And so

[7:04](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=424s) the core idea is that you give um access

[7:07](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=427s) to verbs that can fail out loud loudly

[7:09](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=429s) on a dashboard to your agent and for the

[7:11](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=431s) other ones just involve a human.

[7:14](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=434s) Uh just a bit of context on CI stuff and

[7:18](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=438s) how this plays out for us is that we

[7:19](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=439s) have a test quarantining service behind

[7:20](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=440s) the scenes and it basically holds a list

[7:22](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=442s) of um all the tests that are currently

[7:24](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=444s) skipped because an on call decided that

[7:26](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=446s) it had to uh they had to like break

[7:28](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=448s) glass a certain situation whenever there

[7:29](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=449s) was like an incident or something. Now

[7:31](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=451s) the agent has the ability to reenable

[7:34](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=454s) any one of these own depending on like

[7:35](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=455s) when it evaluates when the tests are uh

[7:38](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=458s) working fine and stuff. Again if it's

[7:40](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=460s) the wrong call the worst that would

[7:41](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=461s) happen is a bunch of different builds

[7:42](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=462s) and tests would just like start showing

[7:44](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=464s) up red and then a human can actually put

[7:45](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=465s) them back very cheaply. The skip is a

[7:48](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=468s) break glass verb itself right like it's

[7:50](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=470s) basically as I mentioned what our on

[7:51](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=471s) call would reach for uh during a very

[7:53](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=473s) critical situation during under pressure

[7:54](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=474s) and stuff. And so in that scenario if

[7:57](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=477s) like uh an agent actually gets it wrong

[8:00](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=480s) a real production bug can actually a

[8:01](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=481s) real bug can walk into production. So

[8:03](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=483s) this needs a human and it will always

[8:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=485s) leave an audit trail. Uh and the key

[8:07](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=487s) detail is that the agent itself is not

[8:09](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=489s) responsible for writing the row or the

[8:10](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=490s) audit trail itself. There is a proxy in

[8:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=492s) the middle that I've highlighted that

[8:13](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=493s) I'm going to talk about in a little bit.

[8:14](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=494s) Uh which is responsible for stamping the

[8:16](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=496s) caller's main identity on every call

[8:18](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=498s) whether it's a skip or an unskip. um the

[8:21](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=501s) agent technically never holds uh the pen

[8:24](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=504s) on its own provenence.

[8:26](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=506s) The second primitive is about rate

[8:28](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=508s) limits. Uh it's pretty standard concept

[8:30](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=510s) but and this is the most concrete form

[8:32](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=512s) of like the budget idea as a whole. So a

[8:34](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=514s) ceiling that refills. So every caller

[8:36](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=516s) gets a small amount of disruptive

[8:38](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=518s) actions uh per time window. So you can

[8:41](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=521s) spend them however you want. Uh there's

[8:42](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=522s) no approval, there's no waiting. And if

[8:44](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=524s) you cross the line, the request simply

[8:46](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=526s) bounces back with a count saying that

[8:47](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=527s) you're actually exceeding your count um

[8:49](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=529s) your budget. You wait a bit and then the

[8:51](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=531s) limit essentially refills. And that's

[8:53](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=533s) that's the whole thing. So the agent

[8:55](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=535s) gets full autonomy within the limit. And

[8:57](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=537s) there is a hard ceiling on how bad a

[8:59](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=539s) single loop can get. And every write

[9:01](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=541s) effectively gets a rate limit. There are

[9:03](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=543s) no exceptions to that. What changes is

[9:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=545s) the size of the rate limit. So if if if

[9:07](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=547s) I'm if I'm trying to delete a bunch of

[9:08](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=548s) workloads in my own name space like my

[9:10](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=550s) my rate limit might be higher but if I'm

[9:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=552s) trying to touch resources in a shared

[9:13](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=553s) namespace my budget or my rate limits

[9:15](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=555s) might be smaller.

[9:19](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=559s) So this is uh effectively the

[9:21](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=561s) solutioning for the incident that I was

[9:23](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=563s) showing earlier. Um after the incident

[9:24](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=564s) the team sort of that sits next to mine

[9:26](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=566s) they they built an admission web hook of

[9:28](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=568s) sorts uh whose sole job is to cap the

[9:31](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=571s) number of deletes at a fixed number per

[9:33](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=573s) hour per resource kind per name space.

[9:35](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=575s) There is always a bypass flag because

[9:37](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=577s) sometimes you genuinely want to delete

[9:39](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=579s) more than you're allowed for and maybe

[9:40](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=580s) some on call scenario or whatever. And

[9:42](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=582s) the part that I absolutely love in this

[9:44](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=584s) case is that inside a cloud code session

[9:46](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=586s) or inside an agent session effectively

[9:48](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=588s) the the bypass flag simply refuses to do

[9:50](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=590s) anything. All it's going to do is tell

[9:52](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=592s) the agent to ask the human to run the

[9:53](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=593s) command itself. So the agent effectively

[9:56](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=596s) gets the rate limit and the human keeps

[9:58](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=598s) the override and nobody effectively has

[10:00](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=600s) to file a ticket for uh the limit

[10:02](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=602s) because it just like refills.

[10:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=605s) The third primitive is about this

[10:07](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=607s) concept of trip wires over allow lists.

[10:10](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=610s) So in my mind like an allow list is

[10:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=612s) effectively a guess that you're making

[10:13](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=613s) up front about what the agent needs or

[10:16](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=616s) about model behavior or agent behavior

[10:17](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=617s) itself. uh I feel like it's pretty

[10:19](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=619s) static and you write it up front before

[10:21](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=621s) before you have any data on like how the

[10:22](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=622s) agent is behaving in different

[10:24](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=624s) situations. A trip wire on the other

[10:26](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=626s) hand is how you get that data like after

[10:28](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=628s) the fact. So for cheap actions you let

[10:30](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=630s) the agent act and every action gets

[10:32](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=632s) recorded with the actor sort of stamp

[10:34](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=634s) identity stamp and these two kind of go

[10:36](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=636s) well together like rate limits are the

[10:38](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=638s) enforcement um they they put a hard

[10:40](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=640s) limit on uh the rate itself. Trip wires

[10:43](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=643s) are how you find out what actually

[10:44](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=644s) happened so you've got something to

[10:46](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=646s) react to. So you effectively watch the

[10:49](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=649s) aggregate and not like individual calls.

[10:51](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=651s) And usually when a trip wire goes off

[10:52](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=652s) the fix is like maybe one or two lines

[10:54](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=654s) in the agents context and not really a

[10:56](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=656s) big code change. Uh the core point is

[10:58](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=658s) that allow lists don't really get better

[10:59](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=659s) over time. They can get stale but trip

[11:01](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=661s) wires do get better over time.

[11:04](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=664s) So here's like a loopin practice for us.

[11:06](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=666s) So like we track one number uh which is

[11:08](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=668s) the number of investigation threads that

[11:10](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=670s) our agent is launching per hour for a

[11:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=672s) given test job failure. So one morning

[11:14](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=674s) say the number was way above the

[11:15](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=675s) baseline and the trip fire page is on

[11:17](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=677s) call and that part's important because a

[11:19](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=679s) trip wire that nobody sees is

[11:21](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=681s) practically useless. Uh it pages after

[11:23](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=683s) the right has already happened after the

[11:25](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=685s) the limit has been crossed not before.

[11:27](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=687s) It's effectively the smoke detector not

[11:29](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=689s) the lock on the door. Uh the agent has

[11:31](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=691s) spun up in this particular scenario a

[11:33](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=693s) bunch of like investigation threads for

[11:34](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=694s) dozens of job that were all failing with

[11:36](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=696s) the same kind of error signature. Each

[11:39](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=699s) thread effectively looked reasonable on

[11:40](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=700s) its own, but like if you took them in

[11:42](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=702s) aggregate, you would realize that it was

[11:43](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=703s) actually an infrastructure failure that

[11:44](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=704s) was causing the same test failure

[11:46](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=706s) signatures across the board. So the fix

[11:48](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=708s) in this case was as simply as telling

[11:51](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=711s) the agent on like, hey, the next time

[11:52](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=712s) you encounter something like this, maybe

[11:53](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=713s) try to correlate a bunch of different

[11:55](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=715s) failures and test jobs and stuff before

[11:57](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=717s) launching a separate investigation

[11:59](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=719s) thread. So that correlation is

[12:00](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=720s) important. Um and the next time when

[12:02](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=722s) this happened, uh it did exactly that

[12:04](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=724s) because that that example and that line

[12:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=725s) of like how it should react and like how

[12:07](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=727s) it should like uh debug things was was

[12:09](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=729s) right there to guide it.

[12:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=732s) So that's three rough primitives. Now

[12:14](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=734s) the lens I mentioned at the start is

[12:16](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=736s) this idea of undo test. And this one's

[12:18](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=738s) slightly different. It's it's not

[12:20](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=740s) something you effectively enforce in

[12:21](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=741s) code. It's the question you ask when

[12:22](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=742s) you're sizing the other three. So it's

[12:25](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=745s) two questions really. One, can the agent

[12:27](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=747s) put it back by itself? and how bad would

[12:29](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=749s) the impact be if it actually got it

[12:31](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=751s) wrong. And this this this sounds like

[12:34](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=754s) asymmetric verbs in a sense, but it's

[12:35](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=755s) kind of difference because the verbs ask

[12:38](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=758s) whether you would notice the failure and

[12:40](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=760s) undo asks whether you can recover from

[12:42](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=762s) it. So if if if the agent can

[12:45](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=765s) effectively roll back its own change and

[12:47](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=767s) the blast radius is acceptable to you,

[12:49](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=769s) you effectively log it and you let it

[12:50](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=770s) go. If either of the answers is no, then

[12:53](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=773s) you effectively need a second key and

[12:55](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=775s) the second key is not something that the

[12:57](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=777s) agent holds itself. It has to be someone

[12:59](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=779s) else. Um, and there has to be an audit

[13:01](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=781s) record so that you can you can track on

[13:03](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=783s) like what happened, why the second key

[13:04](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=784s) was involved and stuff like that.

[13:07](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=787s) Let me let me just show you this another

[13:09](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=789s) example of like how this works outside

[13:10](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=790s) of like the CI domain specifically. So

[13:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=792s) our agent has a key for one of our

[13:14](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=794s) feature flag services. So on the canary

[13:16](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=796s) side which is basically our staging

[13:18](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=798s) traffic and a bunch of like dog fooding

[13:19](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=799s) customers the agent effectively has the

[13:21](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=801s) full dial. It has the ability to um ramp

[13:24](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=804s) up a specific feature flag roll it out

[13:25](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=805s) to uh all of the canary traffic and it

[13:28](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=808s) can take it all the way from zero to 100

[13:30](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=810s) and it also has the ability to sort of

[13:32](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=812s) uh look at any bugs that are being filed

[13:33](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=813s) and toggle it back off and on. What the

[13:35](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=815s) agents key is not scoped to do is for

[13:37](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=817s) promoting the flag to real production.

[13:39](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=819s) The best that an agent can do for now in

[13:41](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=821s) a lot of cases is that it can propose uh

[13:43](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=823s) that an that someone actually promote

[13:45](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=825s) the feature flag in production because

[13:46](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=826s) it's been tested out in Canary. But

[13:48](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=828s) that's pretty much it. Um the second key

[13:51](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=831s) in this scenario is not necessarily a

[13:53](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=833s) new O system. It's a scoped key for

[13:55](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=835s) production and a scoped key for Canary.

[13:59](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=839s) So this is what it looks like day-to-day

[14:01](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=841s) for for me personally. is like I I ask

[14:03](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=843s) cla tag in our slack channel to to own

[14:06](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=846s) the loop the entire loop uh on on

[14:08](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=848s) rolling out a flag. It can it can

[14:09](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=849s) basically ask me a clarifying question

[14:11](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=851s) on whether this is for internal dog

[14:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=852s) fooding group or early access or

[14:13](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=853s) whatever. Uh and the important part is

[14:16](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=856s) that I'm not in the middle of any of

[14:17](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=857s) these things. Every action that the

[14:19](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=859s) agent is taking is stamped with its own

[14:21](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=861s) identity and not mine. And that stamp is

[14:23](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=863s) basically what ties the whole thing the

[14:24](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=864s) whole thing together.

[14:27](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=867s) So the these these primitives they

[14:29](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=869s) compose together nicely because each one

[14:31](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=871s) asks us a different question right the

[14:32](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=872s) verbs ask what the agent is touching the

[14:35](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=875s) rate limit asks how often and the trip

[14:37](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=877s) wires catch what happened afterwards and

[14:39](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=879s) the undo test is sort of the length that

[14:40](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=880s) I personally used to to size all these

[14:42](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=882s) three now the original sort of cold open

[14:45](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=885s) delete that I was showing you the the

[14:46](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=886s) incident itself the rate limit itself

[14:48](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=888s) would have capped it at a few couple of

[14:50](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=890s) tens of workloads itself the undo test

[14:53](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=893s) if you would be thinking about it it

[14:54](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=894s) will basically tell you that you can't

[14:55](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=895s) unddelete a running job in someone

[14:56](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=896s) else's namespace. Um so so anything past

[14:59](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=899s) the cap basically need a human with the

[15:01](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=901s) with a with a second key. So the the

[15:04](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=904s) important part is that you don't need

[15:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=905s) all the checks in every right scenario.

[15:07](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=907s) Only some of these might be relevant for

[15:08](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=908s) like whatever kind of action you're

[15:10](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=910s) trying to evaluate. Uh and if any of

[15:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=912s) these really sound familiar, it it

[15:14](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=914s) should because this is effectively some

[15:16](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=916s) sort of onboarding checklist for your

[15:17](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=917s) engineers like what can a new engineer

[15:19](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=919s) touch, how much rope do they get, who

[15:21](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=921s) signs off on their operations, and how

[15:23](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=923s) do we know it's effectively working? We

[15:25](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=925s) just wrote it for people. It's now the

[15:27](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=927s) same checklist that we want for agents.

[15:30](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=930s) So where does all the policy that I've

[15:32](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=932s) been talking about really live? Uh it's

[15:34](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=934s) two places and I feel like you need

[15:35](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=935s) both. The first one is text. Uh that's

[15:38](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=938s) prompts. That's your context files

[15:40](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=940s) markdown the agent reads before it can

[15:42](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=942s) act. And this is where you can explain

[15:43](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=943s) your why the the intent. We've we got

[15:45](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=945s) exactly the same sentence that I was

[15:47](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=947s) showing earlier um written down in a

[15:48](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=948s) markdown file. It works about 80% of the

[15:51](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=951s) time. Uh the the upside is that it's

[15:53](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=953s) very cheap to change and you can explain

[15:55](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=955s) the reasoning. The downside is you have

[15:57](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=957s) to garden it because the the files can

[15:59](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=959s) grow over time and at the end of the day

[16:00](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=960s) it's just advice. Uh text can shape the

[16:03](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=963s) intent but there is no enforcement

[16:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=965s) anywhere. The the second place is

[16:07](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=967s) infrastructure uh which is the proxy

[16:09](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=969s) layer for us. So the proxy is is not

[16:11](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=971s) reading the prompt. It doesn't know why

[16:13](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=973s) the agent wants to do something and it

[16:15](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=975s) doesn't really care. It will see a

[16:17](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=977s) delete happening. It'll see like a

[16:18](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=978s) budget being crossed and it'll simply

[16:20](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=980s) return a 403 and that's the whole

[16:21](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=981s) conversation really. It's narrow. It's

[16:23](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=983s) deterministic. It it counts, compares,

[16:26](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=986s) it can allow a delete or deny. What it

[16:28](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=988s) can't do is explain the why and a clever

[16:31](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=991s) like prompt injection cannot really talk

[16:32](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=992s) it out of the rule itself. So you need

[16:35](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=995s) both. Uh the text shapes what an agent

[16:37](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=997s) is trying to do and infra is bounding

[16:39](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=999s) how wrong can it go.

[16:42](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1002s) So zooming out, this is where uh the the

[16:45](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1005s) infrastructure sort of really lives for

[16:47](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1007s) us. So like every agent session has its

[16:48](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1008s) own proxy running right next to it. The

[16:51](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1011s) agent starts off by reading its own

[16:52](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1012s) context file. The the markdown files

[16:54](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1014s) that I was showing earlier that's that's

[16:55](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1015s) the text layer and every outbound call

[16:57](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1017s) goes through the proxy after that point

[16:59](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1019s) which is the infrastructure layer. So

[17:00](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1020s) the proxy is not like whatever the agent

[17:03](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1023s) is trying to do the the proxy is only

[17:05](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1025s) responsible for stamping that action

[17:06](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1026s) with the agent's identity. Uh like if

[17:08](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1028s) the if the if the agent is trying to

[17:10](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1030s) launch a bunch of jobs in a Kubernetes

[17:11](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1031s) cluster the the proxy is not following

[17:13](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1033s) it. what is following is the stamp

[17:15](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1035s) itself, the identity itself. So the in

[17:18](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1038s) this example, the cluster would write

[17:20](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1040s) the stamp onto the job as a label. Um

[17:22](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1042s) and every child job or anything that's

[17:24](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1044s) happening afterwards simply inherits the

[17:25](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1045s) same identity and the every safeguard

[17:29](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1049s) that is there in the rest of our systems

[17:30](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1050s) that that are simply they're simply

[17:32](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1052s) reading that like one label. Uh whether

[17:34](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1054s) it's ownership, whether it's kotaas,

[17:35](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1055s) rate limits, approvals, trip wires,

[17:37](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1057s) whatever it is, they're all keyed on the

[17:39](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1059s) same stamp and the agent never got to

[17:41](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1061s) touch it.

[17:43](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1063s) So that's roughly the shape of it. But

[17:45](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1065s) before I wrap up, I want to spend like

[17:47](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1067s) 30 seconds on why it has to be a proxy

[17:49](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1069s) layer, like a different layer that is

[17:50](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1070s) doing the stamping on this identity and

[17:52](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1072s) not the caller itself. Because without

[17:54](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1074s) it, the agent can roughly pick a

[17:55](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1075s) different name. Um, and every limit that

[17:57](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1077s) you've basically set resets.

[18:01](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1081s) So say the agent has the ability to set

[18:04](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1084s) its own identity in a header, right? So

[18:06](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1086s) let's say it hits a specific limit and

[18:08](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1088s) what's the easiest fix from an agent's

[18:10](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1090s) point of view that it can do? it'll just

[18:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1092s) change the header. In this case, it'll

[18:13](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1093s) just say instead of such in such in two

[18:15](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1095s) and voila, you just have a fresh budget

[18:18](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1098s) to work with. Now, in this case, you

[18:20](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1100s) technically don't have a rate limit. You

[18:21](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1101s) just have a suggestion. Uh with the

[18:23](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1103s) proxy in the path, the agent never gets

[18:25](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1105s) to say who it is. The proxy already

[18:27](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1107s) knows. It's the thing that's holding

[18:28](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1108s) real credentials and it stamps every

[18:31](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1111s) call with the identity that it already

[18:32](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1112s) knows, not the one that agent claims.

[18:35](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1115s) And because proxy is the one that is

[18:36](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1116s) stamping, you also get this per session

[18:39](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1119s) ID so that you're able to differentiate

[18:40](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1120s) different sessions that are running all

[18:42](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1122s) for you and see which one's overreacting

[18:44](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1124s) or which one's not acting as it's

[18:46](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1126s) supposed to be.

[18:49](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1129s) U so again just stuffs that I want you

[18:51](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1131s) to take home with is give the agent

[18:54](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1134s) access to verbs that would fail out loud

[18:56](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1136s) uh and keep the human on the ones that

[18:58](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1138s) can fail out quietly. Two, you you put a

[19:00](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1140s) ceiling on every right and that has the

[19:02](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1142s) ability to refill on its own so nobody's

[19:04](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1144s) effectively filing tickets. Three, you

[19:06](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1146s) watch the aggregate and not the

[19:08](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1148s) individual calls that help you

[19:09](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1149s) understand the agents behavior. Um, and

[19:12](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1152s) then you fix whatever you can with the

[19:13](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1153s) sentence. And four, you use the undo

[19:16](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1156s) test to sort of size all of these three

[19:18](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1158s) or any other u primitive that you have

[19:20](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1160s) for your own write operations. And

[19:22](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1162s) underneath all of this uh is is this

[19:24](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1164s) concept of identity which has to come

[19:25](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1165s) from the infrastructure, not from the

[19:27](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1167s) request. I feel like that's one rule. If

[19:29](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1169s) you get that one rule right, everything

[19:31](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1171s) else is uh just just tuning.

[19:34](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1174s) Thank you.

[19:35](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1175s) [applause]

[19:50](https://www.youtube.com/watch?v=rbjWzZK2LU0&t=1190s) [music]
