# Every Company Is Building Agents That Can't Work Together - Justin Schroeder, Standard Agents

Justin Schroeder, Standard Agents

[Talk page](https://ai.engineer/talks/3Krz7Rdd4JI-every-company-is-building-agents-that-cant) · [Video](https://www.youtube.com/watch?v=3Krz7Rdd4JI)

## What It Takes to Hand Someone a Working Agent

A battery warranty claim gives Justin Schroeder a test for agent portability. Hand another team the agent, run the same claim, and see whether it still knows when to ship a replacement.

![A flowchart shows how the warranty agent looks up the equipment, checks coverage and either files the claim or asks the office.](https://ai.engineer/api/talk-essay-media/61eb4acdd45d39523d701dcf9f36a690de86676ed005868e236c95abe4616e54)

Schroeder’s warranty-claim example limits the agent to the equipment lookup, coverage check and filing steps that its owner can evaluate.

### What a warranty agent should be allowed to do

[1:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=98s)

An HVAC technician has photographed a broken part. A warranty claim now needs the equipment record, the photos and a submission to the manufacturer. Justin Schroeder imagines asking a general-purpose assistant to take care of it. When the assistant cannot sign in to the warranty portal, it creates a new account. Perhaps it catches up on a few emails along the way. The example is a joke, but the manufacturer would receive a claim from an account the business never authorized.

Schroeder would give the agent three tools for that job: look up equipment, attach photos and submit a claim. It could still ask for missing information and take several turns to finish. The technician would have latitude over how to describe the fault, and the model could choose which tool to call next. Neither needs authority to create an account. A different agent could handle crew scheduling or state permits, where the same company follows different rules.

The narrow assignment also gives the business something it can measure. Two identical claims ought to reach the same disposition. An unusual one may need a person. Those are cases a warranty team can collect, label and rerun. A higher score on a general model benchmark tells that team little about whether its next claim will be filed correctly. Schroeder argues that a smaller, cheaper model deserves a trial when the team can evaluate it on the actual work.

### What goes missing when you share a working agent

[7:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=470s)

Consider a team that builds a good Gmail agent. The team can tune a model for email and expose the agent as an MCP tool to a larger assistant. A second team now wants to run the email agent in its own environment. Handing over the prompt and tool descriptions leaves out some consequential code. What happens when the model calls two tools at once? How many steps may it take? Which part of a conversation survives a failed request?

These decisions live in the harness, the software that runs the loop around the model. Two companies can both speak MCP and still give different answers to every question above. A Markdown skill can explain what an agent ought to do, and a protocol such as A2A can carry a message between agents. The recipient still has to implement the behavior that made the original agent dependable. Schroeder wants to be able to hand someone a package containing that behavior, down to putting it on a USB drive.

### Specify what the host owes the agent

[14:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=898s)

The open Standard Agent Specification is Schroeder’s proposal for that package and its runtime. An author writes the model selection, prompts, tools and other pieces in TypeScript. The host runs the resulting agent according to a common contract. The author can choose a particular model and test against it. Another company can run the package on its own hardware or implement the host in a different language, provided it can execute the TypeScript and honor the same behavior.

The distinction is easiest to see in a file read. An agent can save a file and read it in a later turn. In the hosted implementation Schroeder shows, a Cloudflare Durable Object reads the contents from a database. The agent sees a file. A local runtime could store the same contents on disk. Requiring the two hosts to expose the same operation gives an agent somewhere else to run without asking its author to adopt the same storage system everywhere.

![A seven-step runtime loop sits beside the storage and ordering guarantees each host must implement.](https://ai.engineer/api/talk-essay-media/cc46e30ff490415143ea4858b27d64bd958b9e769da85aaece67f4fb17678bdf)

A conforming host persists each response and tool result before moving the thread forward.

### Give each side of a conversation a job

[21:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1265s)

The specification describes a conversation as two sides. One side can be a person, a model working from a prompt, or ordinary code. In one example an asset worker produces an answer and an asset reviewer sends it back for another pass. In another, a deterministic handler simply tells the other side to continue. A team can put code in charge of a predictable decision and spend an inference call where an answer genuinely needs judgment.

An agent can also contain another complete agent. Schroeder shows two calendar instances, one for work and one for personal appointments, backed by the same calendar agent. Each instance has a separate job in its parent. Hooks let the installed child participate in specified events in the parent. The author who knows calendar behavior can ship that behavior with the package, while the person assembling the parent decides which calendars it should use.

Suppose someone asks for a reminder about tomorrow’s piano recital. A tool can schedule an effect to fire the next day. A hook serves a different purpose: it runs at a defined point in the current turn, such as immediately before a tool call. Each conversation thread has its own files and key-value store. If its agent can run code, the author can say which modules that code may import and whether it may use the internet.

### A battery warranty becomes the test case

[29:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1796s)

For the demo, Schroeder gave Claude Code a PDF describing a battery warranty process. The coding agent read the policy and generated the model definition, prompts and tools for a specialist. Schroeder reports that this took five minutes and 21 seconds. The resulting files include operations to check a battery, report a safety issue, offer a trade-in and escalate to a lead. An engineer reviewing the output can compare those operations directly with the policy that prompted them.

Standard Agent Builder shows what happened on an actual turn. The runtime sent six tools to the model and the model picked one: ship a replacement. The inspector exposes the request, model, token counts, cost and which tool ran. It reported a 94 percent cache hit rate for that example. That figure describes the displayed request. The reason to inspect it is practical: if a replacement ships when a claim calls for escalation, the operator can see which choices the model received.

A customer used a chat box on a website, while Schroeder inspected the same agent in Builder. The runtime supplies HTTP and WebSocket interfaces, and the agent could also be exposed through MCP for someone using a different assistant. Schroeder closes by inviting people to implement other runtimes and try to break the specification. The real test of portability will come when someone takes a working package out of Builder and runs the same claim somewhere else.

![On the Ottoline help page the support assistant asks about the battery and offers to check coverage.](https://ai.engineer/api/talk-essay-media/1cde918664ccd86d887464990109c3210092d57cff59152d87334e6ddcbc44e4)

The resulting Ottoline assistant opens on the customer’s support page and offers to check the battery’s warranty.

## Resources

- [Standard Agent Specification](https://standardagentspec.org/) — The agent package format and the behavior required of a compatible runtime.

## Slides

### Standard Agents

[0:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=0s) [Opening title of Justin Schroeder’s presentation.](https://assets.ai.engineer/sites/aiecode2025/sha256/9b262f2eebd2daf5b41e07b125aba860c90ccdcb1096842b51f12773ff63ac67.webp)

Standard Agents. Code Summit. Justin Schroeder.

### The prevailing wisdom

[0:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=51s) [MCP servers and Markdown files feed a single general agent in the opening argument.](https://assets.ai.engineer/sites/aiecode2025/sha256/921255d4102c3369a4a9ff7788b724a59b6408b4343e3161af74e2949aa90b87.webp)

The prevailing wisdom. MCP servers + Markdown files → A smart general agent. Call it a day.

### Processes at an HVAC repair shop

[2:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=123s) [A photo of the repair shop accompanies three examples of its work.](https://assets.ai.engineer/sites/aiecode2025/sha256/cfc88d49cbf631b307c0ea28328280367dad044f91184c69ed882ac3417224b5.webp)

An HVAC repair shop. Warranty claims management. Crew and subcontractor scheduling. Permit and approval management.

### Different organizations, different processes

[2:43](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=163s) [The four columns give examples from an HVAC repair shop, a university, a cloud provider and work common to any organization.](https://assets.ai.engineer/sites/aiecode2025/sha256/755ea19cee83436e0895ce7490612822fe5b3b81a13da1459f843475014a31c1.webp)

HVAC repair shop: warranty claims, permit management, crew scheduling, maintenance renewals, refrigerant disposal, change orders. University: admissions, financial aid, course registration, accreditation reporting, grant administration, housing assignments. Cloud provider: incident response, capacity planning, abuse reports, billing disputes, compliance audits, deprecation notices. Any organization: hiring, payroll, procurement, expense approval, contract review, customer support.

### What businesses want from their agents

[4:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=251s) [Four labeled boxes describe the qualities a business wants from its own process.](https://assets.ai.engineer/sites/aiecode2025/sha256/d83a298c57c00d8f9f7c21076268699ce4084e5c35d2839efc3cab164bb3f598.webp)

What businesses want. Control. Reliable. Repeatable. Not generic. It’s their process.

### Why broad capabilities can be a liability

[4:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=267s) [The trust section explains the cost of giving an agent more freedom than its job requires.](https://assets.ai.engineer/sites/aiecode2025/sha256/9abe58c207e575ea73bb2d3fbd33a39597ff2b042b7e0f5e817b427ea864ceeb.webp)

If an agent can do anything, it might do anything. That’s a liability.

### One warranty claim from email to decision

[5:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=314s) [A flowchart shows how the warranty agent looks up the equipment, checks coverage and either files the claim or asks the office.](https://assets.ai.engineer/sites/aiecode2025/sha256/61eb4acdd45d39523d701dcf9f36a690de86676ed005868e236c95abe4616e54.webp)

Claim email arrives → Warranty claims → lookup_equipment → check_warranty_coverage → Covered? Yes: attach_photos → submit_claim → Claim #4471 filed. No: Ask the office.

### What the warranty agent contains

[6:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=375s) [The warranty process gets its own messages, tools, prompt and model.](https://assets.ai.engineer/sites/aiecode2025/sha256/7f8fa478a8bcd1178deebfbab279527a82e059393296e21ca396cc70f4921916.webp)

Permit management. Warranty claims. Crew scheduling. Maintenance renewals. Change orders. Warranty claims agent: Messages, Tools, System prompt, Model. Not just a workflow. A true multi-turn agent.

### Score each business process separately

[6:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=394s) [An illustrative table gives each business process its own evaluation pass rate, cost per task and latency.](https://assets.ai.engineer/sites/aiecode2025/sha256/3e077fc6d93862c0457725c3dccafefc258b3846580d2764748a964e6fa2f870.webp)

Each process gets its own agent. Agent / Eval pass rate / Cost per task / Latency. Warranty claims 96%, $0.004, 1.8s. Permit management 93%, $0.006, 2.4s. Crew scheduling 91%, $0.011, 3.1s. Maintenance renewals 97%, $0.003, 1.2s. Review responses 98%, $0.002, 0.9s.

### Gmail skill and Gmail agent

[7:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=470s) [A dedicated Gmail agent is contrasted with one skill among many in a general agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/e1d57f90f7ab782f7fb7277650eb7bffad132a371542d3ffde7df055bba323be.webp)

A Gmail agent beats a Gmail skill. Claude Opus 5.5 + Gmail skill: one of 41. DeepSeek V4.1 Flash, Gmail agent: one job. Cheaper. You can eval it. Composes into a larger system.

### What sits inside a harness

[9:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=570s) [The harness slide surrounds the model, system prompt, tools and messages with responsibilities such as durable state and stop conditions.](https://assets.ai.engineer/sites/aiecode2025/sha256/785100421698cf28ad04c72687bdd06a73d0d66f89b9e307e5999c8c3669bd37.webp)

To build an agent, you build a harness. Agentic loop orchestration. Stop conditions. Context window management. Provider abstraction. Multi-agent turn coordination. Parallel tool execution. Durable execution. Durable thread state. Tool call validation. Packaging & distribution. Retry with backoff. Execution telemetry.

### Where the standards stop

[11:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=718s) [Six existing protocols cover tool access, know-how, project instructions, agent communication and payments, with the harness left open.](https://assets.ai.engineer/sites/aiecode2025/sha256/00f692b617bf1ec5e706c5b752a9326f61b65c6b00915d6de00e7f3dacfa8c2d.webp)

Existing standards. Tool access: MCP. Packaged know-how: Skills. Project instructions: AGENTS.md. Agent ↔ agent: A2A. Editor ↔ agent: ACP. Payments: AP2 · x402. The harness itself: nothing yet.

### What a specification buys

[12:42](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=762s) [The four boxes name the benefits of sharing a standard agent specification.](https://assets.ai.engineer/sites/aiecode2025/sha256/637910f830e54f50b22b7e99112b8fdb57045f3ad7655ce8a46ce75477229ac0.webp)

What a spec buys you. Speed. Consistency. Portability. Composability.

### The Standard Agent Specification

[13:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=801s) [The announcement slide gives the specification’s name and public site.](https://assets.ai.engineer/sites/aiecode2025/sha256/eb4c5b278d3db09a3cd58d6ec68e506b6fe7b4715d1d806c2341488281a4d7c8.webp)

Today we’re open sourcing The Standard Agent Specification. An open source, engineering-first approach to building agents. standardagentspec.org.

### Five properties for an agent

[13:35](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=815s) [Justin lists five goals for an agent that can move among hosts.](https://assets.ai.engineer/sites/aiecode2025/sha256/0b510b93fc0ae40a4a9df0c9e552319c09ca097b6fe152a77a319f013ead0838.webp)

Agents should be vendor-agnostic. Agents should be domain-specific. Agents should be coupled to a model. Agents should be composable. Agents should be portable.

### Runtime, package and thread

[14:52](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=892s) [A nested diagram locates prompts, tools, hooks and the thread’s state within the package and runtime.](https://assets.ai.engineer/sites/aiecode2025/sha256/84cad2da0ee7a912110d42afde0284f57bff5a938806816175537d7ffe67486a.webp)

Here’s the map. Runtime. Package. Thread. Messages, Files, Code, KV, Decisions. Endpoints. Hooks. Effects. Agent rules. Subagents. Tools. System prompt. Model.

### Two sides of an agent conversation

[21:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1260s) [Rows pair the two sides of a conversation for an assistant, reviewer, relay and approval gate.](https://assets.ai.engineer/sites/aiecode2025/sha256/4cc352f55d57a71e319e80cb9f05bb47648d6d9bcc620410012b6e52c70b3725.webp)

Side A ↔ Side B. human, prompt, handler. prompt × human: the everyday assistant. prompt × prompt: worker and reviewer. handler × human: deterministic relay, zero model calls. prompt × human, as a child: approval gate inside an automated pipeline.

### Required parent hooks

[23:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1404s) [The Gmail subagent example illustrates how a parent must provide a hook before the child can run.](https://assets.ai.engineer/sites/aiecode2025/sha256/d46b394fa2b249f7fef7f73f33df65e9356b33445c96440f007de6cd58d5c07b.webp)

Required parent hooks. Installing does nothing. You see what it needs. No hook, no run.

### The thread owns its environment

[25:04](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1504s) [A grid identifies the state and operations available to a running thread.](https://assets.ai.engineer/sites/aiecode2025/sha256/2a245b5cc271942c712652f04d09f8c905a9f7b72d0cf8542a18d6b13f465ad3.webp)

Every thread is a full environment. Messages. File system. Code execution. Subagents. Environment. Tools. Effects. Events. Key-value. Decisions. One ThreadState interface, the same from tools, hooks, handlers, and endpoints.

### The runtime contract

[27:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1643s) [A seven-step runtime loop sits beside the storage and ordering guarantees each host must implement.](https://assets.ai.engineer/sites/aiecode2025/sha256/cc46e30ff490415143ea4858b27d64bd958b9e769da85aaece67f4fb17678bdf.webp)

The runtime contract. Drain queued messages and tools. Assemble context. Call the model. Persist the response. Execute tool calls. Persist tool results. Evaluate stop conditions. A conforming runtime MUST: one step at a time per thread, persist before advancing, enforce stop and safety semantics, durable queues, copy attachments across threads, durable per-thread key-value store, honor the sandbox contract.

### A coding agent as a package

[28:17](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1697s) [The production example shows a planning agent above frontend, graphics, systems and backend agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/edc6edc3f3e1bc002e6f37d98682ffbf2e6076fe695cb6f18ba2b79d9b2ac66f.webp)

A coding agent built as a standard agent package. Architecture & Planning. Baseline. Frontend. 3D & Graphics. Systems. Backend & Data.

### Standard Agent Builder

[29:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1767s) [The first runtime demonstrates the path from a local clone to a deployable agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/bb28408036188d82ddbe5f6126fa7f5c35ff035674c7a46c65c16c945cbb27cd.webp)

Standard Agent Builder. The first runtime for the Standard Agent Specification. Clone it. Ask your coding agent. Run it anywhere.

### The bicycle warranty assistant in the storefront

[32:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1951s) [On the Ottoline help page the support assistant asks about the battery and offers to check coverage.](https://assets.ai.engineer/sites/aiecode2025/sha256/1cde918664ccd86d887464990109c3210092d57cff59152d87334e6ddcbc44e4.webp)

How can we help? Battery & charging. Warranty. Orders & delivery. Service & repairs. Ottoline Support: Hi there! I can check battery warranty coverage and sort out a replacement. What’s going on with your battery?

### Build it with us

[33:48](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2028s) [The closing slide invites new runtimes, shared agents and feedback on the draft specification.](https://assets.ai.engineer/sites/aiecode2025/sha256/224c12f2e87cddf518ba16a6976219e176c73e6474050b49e49b3378c7c9f4fc.webp)

Build it with us. Build a runtime. Build agents. Break the spec. It’s 0.2. Open issues and pull requests.

## Full transcript

[0:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=0s) Hey, my name is Justin Schroeder. I want

[0:02](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2s) to talk to you about standard agents and

[0:04](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=4s) specifically standardizing agents. But

[0:06](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=6s) before I do, I want to mention an

[0:09](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=9s) interesting observation. Um, right now

[0:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=11s) I'm noticing that everybody's building

[0:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=13s) agents. Um, if you walk down your street

[0:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=15s) today, you're probably going to run into

[0:17](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=17s) people who are building agents to help

[0:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=19s) power their business. And this is

[0:20](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=20s) actually weird because it goes against

[0:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=23s) the prevailing wisdom of the day. Right

[0:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=25s) now, most people who are deep in AI are

[0:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=27s) going to tell you that the right way to

[0:29](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=29s) put your business and and enable your

[0:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=32s) business with AI is to build an MCP

[0:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=34s) server that exposes the pieces and parts

[0:36](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=36s) of your business and then write some

[0:39](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=39s) markdown files, skill files or uh agents

[0:41](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=41s) MD files, right? You you write some

[0:43](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=43s) markdown files basically documentation

[0:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=45s) and then you give it to a sufficiently

[0:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=47s) smart uh model. So something like you

[0:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=49s) know a claude or Grockbot agent,

[0:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=51s) something like that and then you call it

[0:52](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=52s) a day. this is sufficient and this is

[0:54](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=54s) going to do the job. And what's

[0:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=56s) interesting is people just aren't doing

[0:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=58s) this. Well, I mean, people are building

[0:59](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=59s) MCP, but they're still building agents.

[1:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=63s) So, we could view this potentially as

[1:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=65s) they're just making a mistake. Maybe

[1:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=67s) these people are just doing the wrong

[1:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=68s) thing and we need to advise them better.

[1:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=70s) And that might be true. But I actually

[1:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=72s) think that there's some wisdom in what

[1:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=73s) the market is showing us. There's

[1:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=75s) something more there that I want to talk

[1:17](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=77s) about. And I think it comes down to

[1:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=78s) three factors. I think there's three

[1:20](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=80s) primary reasons why people are still

[1:22](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=82s) building agents and I want to walk

[1:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=83s) through them before we get into

[1:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=85s) standards. First is integration.

[1:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=88s) Businesses need their processes that are

[1:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=91s) deeply embedded inside of their business

[1:33](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=93s) to be handled properly. These are not

[1:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=97s) small factors for the business. For

[1:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=98s) example, take something like an HVAC

[1:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=100s) repair company. You have all kinds of

[1:41](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=101s) business processes that make up that

[1:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=104s) organization. Things like, you know,

[1:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=105s) managing warranty claims. How do you

[1:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=107s) know when a warranty claim comes in that

[1:48](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=108s) it's within the appropriate period or

[1:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=110s) that it's one of the things that was

[1:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=111s) guaranteed? How about crew scheduling?

[1:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=113s) Crews are running all over a big city

[1:55](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=115s) trying to perform various operations.

[1:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=116s) How do you know that the right people

[1:57](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=117s) are going to the right places? This is

[1:59](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=119s) critical for their business to function

[2:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=121s) well and they already have lots of

[2:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=123s) software to help handle this. How about

[2:04](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=124s) pulling permits from the state? How

[2:06](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=126s) about campaign management or account

[2:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=128s) expansion or job materials? There are so

[2:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=131s) many important processes that a given

[2:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=134s) business needs for it to operate

[2:16](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=136s) effectively.

[2:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=138s) And it's not just HVAC repair. HVAC

[2:20](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=140s) repair has a bunch, but universities,

[2:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=141s) how about financial aid? How do we make

[2:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=143s) sure that financial aid is appropriately

[2:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=145s) given out or grant administration or

[2:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=148s) housing assignments? How about something

[2:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=150s) like a cloud provider? Making sure that

[2:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=152s) um we aren't having abuse or billing

[2:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=154s) disputes. There are all kinds of

[2:36](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=156s) important processes that are currently

[2:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=158s) being handled that if you want to

[2:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=160s) integrate AI need to be handled properly

[2:43](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=163s) and it's not just three, it's really any

[2:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=165s) organization. There's all kinds of other

[2:46](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=166s) higher order things like payroll or

[2:48](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=168s) contract review. All of these are

[2:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=170s) important processes. It turns out that a

[2:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=173s) business is really just its processes.

[2:57](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=177s) That is its foundation, its core. In

[3:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=180s) fact, everything that makes a given

[3:02](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=182s) business valuable is really the result

[3:04](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=184s) of the processes that got there. So

[3:06](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=186s) things like relationships and network

[3:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=187s) effects and proprietary data, all of

[3:09](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=189s) those come as a result of the process

[3:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=192s) working really well, whatever that is

[3:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=194s) and however many that is, right? So the

[3:16](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=196s) idea that we're going to use something

[3:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=198s) like Grockbot to start running all of

[3:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=201s) those processes,

[3:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=203s) honestly, it is it's just not palatable.

[3:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=208s) People do not want this. Even if it

[3:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=210s) works well, which it probably will with

[3:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=212s) some of these really big models. It's

[3:35](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=215s) too risky. It's too risky to take their

[3:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=217s) business critical process, the thing

[3:39](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=219s) that makes them who they are as a

[3:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=220s) business, and hand that over. So, what

[3:43](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=223s) businesses really want, and we've found

[3:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=225s) this even in our own experience, is they

[3:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=227s) really want control. And then they need

[3:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=229s) to trust the process. They need to have

[3:52](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=232s) reliable execution over time. And it

[3:55](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=235s) needs to be repeatable. It needs to work

[3:57](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=237s) the same way for the same claim. Okay?

[4:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=240s) And finally, it can't be generic. You

[4:02](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=242s) just can't use completely generic tools

[4:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=245s) to perform this, right? There's a voice.

[4:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=247s) There's a tone that a given business has

[4:09](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=249s) that they want to preserve. So that's

[4:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=251s) integration. The second part I think

[4:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=254s) that businesses really need is they need

[4:16](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=256s) to be able to trust what the agent does.

[4:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=259s) And what we like to say around here is

[4:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=261s) that if an agent can do anything, it

[4:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=264s) might do anything. And that is a

[4:26](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=266s) liability. In fact, that's a really big

[4:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=268s) liability and something that is

[4:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=270s) untenable.

[4:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=271s) So, you really need to restrict what

[4:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=274s) Grockbot can do down to something

[4:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=277s) really, really fine-tuned, right? You

[4:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=278s) know, I mean, here this I'm obviously in

[4:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=280s) Jest, but you know, hey, did you get the

[4:42](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=282s) warranty claim? Yeah, couldn't sign into

[4:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=284s) the warranty portal, so I made a new

[4:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=285s) account, right? I mean, it's not out of

[4:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=287s) the question that Grockpot would do

[4:48](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=288s) something like that or I replied to some

[4:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=290s) emails while I was at it. I read up on

[4:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=291s) the election results, so on and so

[4:52](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=292s) forth. And the reason of course is just

[4:54](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=294s) because it has those tools. It has the

[4:55](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=295s) ability to do that. Now, usually these

[4:57](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=297s) smart models don't make those result,

[4:59](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=299s) those errors, those those kinds of

[5:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=301s) mistakes, but it absolutely can happen,

[5:04](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=304s) right? So, Grockbot has the ability to

[5:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=307s) go check an X account while it's in the

[5:09](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=309s) middle of performing some other

[5:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=311s) operation. And businesses don't want

[5:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=313s) that. They don't want that. Now,

[5:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=315s) instead, what they want is a very clear

[5:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=318s) workflow where some claim is, you know,

[5:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=321s) warranty claim is triggering a given

[5:22](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=322s) agent to pick up some work. And that

[5:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=324s) agent has very specific tools like

[5:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=327s) looking up equipment, attaching photos,

[5:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=328s) submitting a claim. Now, these are full

[5:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=331s) agents. They have multi-turns. They can

[5:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=334s) perform real work. They can do

[5:35](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=335s) evaluation. They have their own context,

[5:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=337s) but they are limited in their scope to

[5:39](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=339s) what they can actually perform. We're

[5:41](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=341s) not just trusting that a model's not

[5:43](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=343s) going to go do that.

[5:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=345s) So trust number two absolutely critical.

[5:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=349s) Number three is efficacy not efficiency

[5:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=353s) efficacy. This is the most important of

[5:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=356s) the three perhaps. We need to make sure

[5:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=358s) that the job is done and it's done well.

[6:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=360s) You know it's it's not enough to say

[6:02](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=362s) like is my model smart enough but can it

[6:04](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=364s) do the task it's been given? Can it do

[6:06](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=366s) it efficiently? And in the in the

[6:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=368s) totality, does it improve the

[6:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=370s) performance of the business or of that

[6:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=372s) process over what we were previously

[6:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=374s) doing? That is absolutely important. So,

[6:17](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=377s) think about, you know, our HVAC uh

[6:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=379s) warranty claim. Our warranty claim

[6:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=381s) itself, that's a small task for an

[6:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=383s) agent, but what we're saying is that

[6:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=385s) would actually make a great agent. That

[6:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=388s) entire thing, just the warranty claim

[6:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=390s) would be an agent. It's not a workflow.

[6:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=392s) It has multiple turns. It is a

[6:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=394s) legitimate agent. And what's really cool

[6:36](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=396s) about this is you can take all of your

[6:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=397s) business processes and then you can eval

[6:39](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=399s) them. Right? When you try to eval a really large language model, it's being evaled on so many different things. And what you see is effectively a

[6:48](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=408s) form of benchmaxing over time where it

[6:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=410s) tries to get really good at the things

[6:52](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=412s) that are being observed. That's not a

[6:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=413s) bad thing. It's just bad if what you are

[6:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=416s) wanting out of it is not one of those

[6:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=418s) things. But with an agent that is

[7:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=420s) fine-tuned for a very specific task,

[7:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=423s) that benchmaxing is actually a positive.

[7:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=425s) It's a good thing for an individual

[7:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=428s) model with an individual prompt with an

[7:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=430s) with individual tools to have a very

[7:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=432s) high efficacy rate and a very high eval

[7:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=435s) pass rate if that's all that they're

[7:16](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=436s) being asked to do.

[7:20](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=440s) So the current state of affairs is that

[7:22](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=442s) we use super super smart models like you

[7:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=444s) know opus 55 which is a spectacular

[7:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=447s) model and and then we just give it more

[7:29](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=449s) tools and more skills and I don't want

[7:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=451s) to say that this doesn't work because we

[7:33](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=453s) have created an ecosystem where this

[7:35](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=455s) works tremendously well however it can

[7:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=458s) it is also very very large as opposed to

[7:42](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=462s) creating something with you know

[7:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=464s) deepseek v4.1 flash that is only

[7:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=467s) performing one operation something

[7:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=469s) something like the warranty claims

[7:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=470s) agent. So fundamentally a Gmail agent

[7:54](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=474s) beats a Gmail skill. It's not that both

[7:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=476s) of them don't work. Of course, Claude

[7:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=478s) can very easily use a skill to go check

[8:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=480s) Gmail or probably do it without a skill.

[8:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=483s) But Deepseek v4.1 Flash can actually do

[8:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=485s) a tremendous job of this. So it's

[8:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=488s) definitely going to be cheaper.

[8:09](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=489s) Obviously Flash is incredibly cheap. Um

[8:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=492s) but you can actually eval that tiny

[8:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=493s) little agent. And if you guys remember

[8:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=495s) the Jeepa paper from uh several months

[8:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=498s) ago, it said that fine-tuning an agent

[8:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=501s) is actually more effective fine-tuning

[8:22](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=502s) the prompt of an agent than fine-tuning

[8:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=504s) a model. And that is absolutely true. We

[8:26](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=506s) can get DeepSeek V, you know, 4.1 Flash

[8:29](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=509s) to do a tremendous job, an incredible

[8:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=511s) job of just being a Gmail agent. That's

[8:33](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=513s) very simple. It only falls apart when

[8:35](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=515s) you ask it to be way more than that. And

[8:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=517s) then finally, you can compose it into a

[8:39](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=519s) larger system. You could even expose the

[8:41](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=521s) Gmail agent as an MCP server to Opus 55.

[8:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=525s) Or you could create an hierarchy of

[8:48](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=528s) these smaller agents all working

[8:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=530s) together under some larger agent that

[8:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=533s) has a defined task as well. So if these

[8:57](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=537s) smaller domain specific agents are so

[8:59](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=539s) great, why aren't they everywhere? Why

[9:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=541s) isn't everybody using them everywhere?

[9:04](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=544s) Well, they sort of are, right? Because

[9:06](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=546s) everybody kind of is building agents

[9:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=548s) right now. The problem is that they're

[9:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=550s) just a mess. Everybody's writing them in

[9:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=552s) all kinds of different languages,

[9:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=553s) writing all kinds of different tools,

[9:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=555s) all kinds of different uh agentic loops.

[9:17](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=557s) It's it's a bit of a mess. And the truth

[9:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=559s) is that agents are actually hard. The

[9:20](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=560s) base is really simple, right? You just

[9:22](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=562s) have a model, then you've got a system

[9:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=564s) prompt of some kind. You put some tools

[9:26](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=566s) in there, then you have a message

[9:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=567s) histories. Uh but in reality, of course,

[9:29](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=569s) it's actually very hard. There are so

[9:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=571s) many things to worry about. Um there's,

[9:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=574s) you know, the actual orchestration of

[9:35](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=575s) the loops, how many steps it can take

[9:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=577s) before there's a problem. You have

[9:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=578s) parallel tool execution where you need

[9:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=580s) some sort of async system to handle

[9:42](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=582s) those. You need durability so we can

[9:43](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=583s) pick up after errors. There is a lot

[9:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=585s) that goes into building an agent. And

[9:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=587s) really in order to build an agent, what

[9:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=589s) you're really doing is you're building a

[9:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=591s) harness. And even if you did go down the

[9:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=593s) MCP path and all you were doing was MCP,

[9:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=596s) well often you're going to find and a

[9:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=598s) lot of businesses that we talked to are

[10:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=600s) finding that they also need inference.

[10:04](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=604s) The tools themselves need inference to

[10:06](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=606s) become more val more more valuable. But

[10:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=608s) if you're going to start providing

[10:09](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=609s) inference there, then pretty soon you

[10:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=611s) need multiple steps of inference and all

[10:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=612s) of a sudden you've recreated another

[10:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=615s) agent system just within MCP. But even

[10:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=618s) if you did build a custom harness, there

[10:20](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=620s) are still important problems that have

[10:22](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=622s) to be solved. For example, I can't build

[10:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=624s) a custom harness and you build a custom

[10:26](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=626s) harness and then we just easily share

[10:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=628s) with each other. It might not run in my

[10:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=630s) hosting environment. There's all kinds

[10:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=632s) of questions about how you would

[10:33](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=633s) actually share that with someone else.

[10:35](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=635s) Or how about composition? How do you

[10:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=637s) actually put two of these things

[10:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=638s) together and have them work efficiently

[10:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=640s) together? If I built mine in a different

[10:42](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=642s) way than yours, then they're in they're

[10:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=644s) fundamentally incompatible. And we're

[10:46](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=646s) not building them at scale. Like I don't

[10:48](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=648s) want to build hundreds of these custom

[10:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=650s) agents. That's insane. I don't want to

[10:52](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=652s) do that and then ultimately just end up

[10:54](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=654s) with Grockbot at the end of the day.

[10:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=656s) There has to be something better than

[10:57](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=657s) that. And we see this because even

[11:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=661s) skills aren't being written entirely by

[11:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=663s) one person, right? There's an entire

[11:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=665s) ecosystem of people's people writing

[11:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=667s) skills. Again, these are just markdown

[11:09](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=669s) files. So the idea that one person is or

[11:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=672s) one business is going to create hundreds

[11:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=674s) or thousands of their own agents that

[11:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=675s) are interoperable is a little bit silly.

[11:17](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=677s) We need an ecosystem of sharable agents

[11:20](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=680s) instead. So the solution is obviously

[11:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=684s) standards, right? That's the whole point

[11:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=685s) of my talk. We're talking about standard

[11:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=687s) agents and what's interesting is that we

[11:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=690s) have standardized agents to a large

[11:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=692s) degree. We've standardized the things

[11:33](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=693s) around them. Right? So for tools we have

[11:35](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=695s) MCP basically tool distribution

[11:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=698s) standards. Uh skills are basically a

[11:41](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=701s) form of prompts that we have decided we

[11:43](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=703s) can standardize. They have agents MD

[11:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=705s) another form of prompts. We have A2A for

[11:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=707s) for intercommunication. We have ACP and

[11:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=710s) we've got you know X42 if you want to do

[11:52](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=712s) payments. There's all kinds of standards

[11:54](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=714s) that are starting to evolve around the

[11:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=716s) agent ecosystem, but as of today, there

[11:59](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=719s) is nothing for the harness itself. There

[12:02](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=722s) is no agent runtime. And this is

[12:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=725s) important because what a spec actually

[12:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=727s) gets you is incredibly important. First

[12:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=730s) of all, speed. You don't have to

[12:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=733s) reinvent the world every time you create

[12:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=735s) an agent, right? You can have the exact

[12:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=738s) ampic loop specified. We can know

[12:20](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=740s) exactly how to write tools. Our agents

[12:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=743s) are not responsible for building that

[12:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=745s) part of the ecosystem. Consistency.

[12:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=748s) Every agent should be built exactly the

[12:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=750s) same way. Now that doesn't mean that

[12:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=752s) every agent is just a markdown file. It

[12:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=754s) needs to have deep, deep ability to

[12:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=757s) customize, but those customizations

[12:39](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=759s) should automatically work in any

[12:42](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=762s) compatible runtime. There's also

[12:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=764s) portability. I need to be able to write

[12:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=765s) an agent, pack it up, and literally put

[12:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=767s) it on a zip drive if I want to or a USB

[12:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=770s) stick and give it to you. And of course,

[12:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=773s) composability. This is, you know,

[12:55](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=775s) perhaps a little bit of a vague and

[12:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=776s) overused term, but all it means is that

[12:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=778s) you're assembling smaller parts into

[13:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=780s) something larger than itself. And

[13:02](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=782s) composability is really a huge key to

[13:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=785s) unlocking how domain specific agents can

[13:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=788s) be brought to the market. So, we need

[13:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=791s) this. But unfortunately,

[13:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=793s) no such spec exists

[13:17](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=797s) until today.

[13:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=799s) And I am really excited to tell you

[13:22](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=802s) about the standard agent specification.

[13:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=805s) We are announcing it literally today as

[13:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=807s) you are watching this. It is an

[13:29](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=809s) open-source spec. It's available today

[13:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=812s) at standardagentspec.org.

[13:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=814s) And I'd like to show it to you a little

[13:35](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=815s) bit. To start with, we make some claims.

[13:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=818s) First, this is our definition of agents.

[13:41](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=821s) Agents are deterministic software that

[13:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=824s) harness the non-deterministic results

[13:46](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=826s) produced by models in pursuit of a

[13:48](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=828s) desired objective. If that sounds a lot

[13:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=830s) like a harness, it even has the word

[13:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=831s) harness in it. It's intentional. A good

[13:54](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=834s) agent is a good harness. You could

[13:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=836s) almost think of an agent like an

[13:57](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=837s) instance of a harness. And then there

[14:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=840s) are five other core principles that the

[14:02](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=842s) spec is built on. First of all, agents

[14:04](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=844s) need to be vendor agnostic. Agents

[14:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=847s) should be domain specific. Agents should

[14:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=850s) be coupled to a given model. Agents

[14:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=853s) should be composable. And agents should

[14:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=855s) be portable. I want to talk about two of

[14:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=858s) these that seem like they're

[14:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=859s) contradictions. The vendor agnostic

[14:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=861s) thing and the couple to a model. Vendor

[14:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=863s) agnostic means I don't want my agent

[14:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=864s) running exclusively on anthropics

[14:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=867s) hardware or exclusively within the

[14:29](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=869s) OpenAI ecosystem. I need to be able to

[14:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=871s) host it wherever I want to host it and I

[14:33](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=873s) need to be able to run whatever models I

[14:35](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=875s) need to run. That being said, an

[14:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=878s) individual agent is almost always best

[14:41](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=881s) when it's paired with a specific model.

[14:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=884s) Now, this starts to be less true on the

[14:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=887s) large model front, but even there it's

[14:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=890s) true. Different harnesses do produce

[14:52](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=892s) different results. So, let me give you a

[14:54](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=894s) little bit of a tour here of the

[14:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=896s) specification. First, we have the

[14:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=898s) runtime. An agent runs in a runtime very

[15:02](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=902s) similar to how a language runs in a

[15:04](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=904s) runtime. The language in this case is

[15:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=905s) the definition of the agent and the

[15:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=907s) runtime is what is so highly specified.

[15:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=910s) But if we take a look inside, we'll see

[15:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=912s) that agents are really just packages

[15:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=914s) with lots of pieces and parts which are

[15:16](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=916s) painfully and excruciatingly detailed in

[15:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=919s) the specification. So we're going to

[15:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=921s) keep this little map here of model,

[15:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=923s) system prompt, tools, sub aents, agent

[15:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=925s) rules, hooks, effects, and then the

[15:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=927s) thread. all of that map and we're going

[15:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=928s) to walk through some of these piece by

[15:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=930s) piece. So first of all, everything in

[15:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=934s) the specification is intended to be

[15:36](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=936s) written as code. Now this is important

[15:39](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=939s) for two reasons. One, we need to be able

[15:41](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=941s) to pack this up and distribute it. I

[15:43](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=943s) need to be able to take an agent and

[15:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=945s) everything that that means, every piece

[15:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=947s) of information that has to do with that

[15:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=949s) agent, and I need to be able to pack it

[15:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=951s) up, literally put it on a USB stick and

[15:54](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=954s) hand it to you or publish it to a

[15:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=956s) package registry. And the only way we're

[15:59](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=959s) going to do that is if everything is

[16:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=960s) code. So, first everything has to be

[16:02](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=962s) code. Also, we want to be able to write

[16:04](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=964s) agents with agents. I don't want to sit

[16:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=967s) down and handwrite an agent. That's

[16:09](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=969s) crazy. So, of course, it needs to be

[16:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=971s) code. So it is an agent first ecosystem.

[16:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=975s) So let's take a look at how these are

[16:17](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=977s) actually written. We made a really

[16:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=979s) interesting decision early on. We

[16:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=981s) decided that we needed to have all of

[16:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=983s) the agents written according to the

[16:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=985s) specification in the same language and

[16:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=987s) we chose TypeScript. Now we didn't

[16:29](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=989s) choose TypeScript because we're big

[16:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=991s) TypeScript fans. It's fine. Uh we chose

[16:33](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=993s) TypeScript because in today's era,

[16:35](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=995s) languages really almost have no value.

[16:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=998s) The only value a language has is the

[16:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1000s) artifact that it produces at the end.

[16:42](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1002s) What's unique about it? And in our

[16:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1004s) opinion, there's really only two

[16:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1005s) languages that matter. I know some of

[16:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1007s) you are going to disagree with this, but

[16:48](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1008s) the two languages are Rust or Rustlike

[16:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1011s) systems that that write extremely fast

[16:54](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1014s) performant code and TypeScript. Now, why

[16:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1016s) TypeScript? Typescript because it runs

[16:59](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1019s) everywhere, absolutely everywhere. It

[17:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1021s) runs on the edge. It runs on your

[17:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1023s) computer. It runs on your mom's

[17:04](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1024s) computer. It runs on your phone. It runs

[17:06](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1026s) everywhere. And in this particular case,

[17:09](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1029s) we want agents to run everywhere. But

[17:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1031s) there is a second reason. Typescript is

[17:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1033s) an interpreted language. Well,

[17:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1034s) technically JavaScript is. JavaScript is

[17:16](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1036s) an interpreted language. And we want

[17:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1038s) that because we want our agents to be

[17:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1041s) able to write agents and execute them

[17:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1043s) immediately without a build or a

[17:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1045s) compilation step. And the only way we're

[17:26](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1046s) going to do that is by using an

[17:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1048s) interpreted language. And as far as

[17:29](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1049s) interpreted languages go, TypeScript is

[17:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1051s) about as robust, fast, available, and

[17:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1054s) portable as any of them out there. We

[17:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1057s) didn't want to do the MCP thing that

[17:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1060s) already exists. MCP requires you to have

[17:42](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1062s) some sort of server in order to serve

[17:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1065s) the tools. We don't want to do that. We

[17:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1067s) want to be able to bundle it all

[17:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1069s) together. So this is what it looks like.

[17:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1071s) If you want to define a model, you do

[17:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1073s) that in Typescript. All of this is very

[17:55](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1075s) tightly typed. If you want to define a

[17:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1078s) prompt, you define the prompt using

[18:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1080s) define prompt. You want to define an

[18:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1081s) agent, you do it with define agent. Now,

[18:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1085s) one really important fact is that models

[18:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1088s) uh models that are defined in code

[18:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1091s) define the exact model that they are

[18:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1093s) running on. So, my agent is going to run

[18:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1095s) on a specific model of OpenAI. And of

[18:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1098s) course, you can have fallback models. So

[18:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1101s) if my primary model fails then we

[18:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1103s) recommend you go up a level of

[18:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1104s) intelligence and switch to another one.

[18:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1107s) This gives us a tremendous advantage

[18:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1108s) that we can use the jaggedness of an

[18:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1111s) LLM. So a good example is uh you know we

[18:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1114s) have this fun project called model zen

[18:36](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1116s) garden and model zen garden creates lots

[18:39](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1119s) of different uh 3D zen gardens for

[18:41](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1121s) people to walk through and what we found

[18:43](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1123s) is one model in particular um 10 cents

[18:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1125s) y3 was spectacular at producing 3D

[18:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1129s) gardens at a fraction of the cost of all

[18:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1131s) the others. It wasn't a very good model

[18:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1133s) but this is the jaggedness. it was good

[18:55](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1135s) at that one characteristic and one

[18:57](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1137s) trait. And for domain specific agents,

[18:59](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1139s) that actually is a benefit, not a

[19:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1141s) hindrance. So, it's great to be able to

[19:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1143s) use a smaller model for a small task

[19:06](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1146s) that it's very, very good at. And right

[19:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1148s) now, we've sort of all been trained that

[19:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1150s) you write your agent and then you just

[19:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1151s) swap out models willy-nilly and you kind

[19:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1154s) of hope for the best. That goes against

[19:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1155s) one of our fundamental principles, which

[19:17](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1157s) is efficacy. We need high efficacy. And

[19:20](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1160s) so it is almost always better to pin a

[19:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1163s) very specific model running at a

[19:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1165s) specific quant by a specific pro

[19:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1167s) provider to your agent.

[19:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1170s) Next are prompts. Prompts are what they

[19:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1172s) sound like. These are the system

[19:33](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1173s) prompts. But interestingly, they own one

[19:36](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1176s) side of the conversation. So

[19:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1177s) conversations for agents are basically

[19:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1180s) always two-sided. You have the assistant

[19:42](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1182s) and you have the user. And in this case,

[19:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1184s) the prompt is owning one side of that

[19:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1187s) conversation. And another interesting

[19:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1189s) thing you can do is you can include

[19:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1191s) prompts inside of other prompts. They

[19:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1193s) are effectively rendered at runtime. So

[19:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1196s) if you have environment variables that

[19:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1198s) are public or things like that that you

[19:59](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1199s) want to get written into the prompt at

[20:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1201s) runtime, that is completely possible. Or

[20:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1205s) perhaps you have something like a tone

[20:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1207s) prompt where you have got lots of

[20:09](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1209s) different sub aents and all those sub

[20:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1210s) aents need to speak to users in a

[20:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1212s) particular way. That's not a problem.

[20:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1214s) you can just make that happen uh by

[20:16](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1216s) including a singular prompt in all of

[20:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1219s) them that says hey you're going to speak

[20:20](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1220s) this way.

[20:22](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1222s) Now tools are basically one of three

[20:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1225s) kinds. You either have a function where

[20:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1227s) you actually run some code in Typescript

[20:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1230s) or it's a prompt. So this is really

[20:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1232s) useful when you need to perform a little

[20:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1234s) bit of inference somewhere else like I

[20:35](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1235s) need to just use nano banana to produce

[20:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1238s) an image but I don't need a full sub

[20:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1240s) aent to do that. um or this one model is

[20:43](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1243s) actually better than my primary model at

[20:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1245s) sounding like a human. So, one of my

[20:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1247s) tools is actually a prompt. It's just a

[20:48](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1248s) subprompt, not a sub aent. And then the

[20:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1250s) third type of tool is an entire agent, a

[20:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1253s) whole sub agent. So, I can call an agent

[20:57](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1257s) as a tool and it will just work. This is

[20:59](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1259s) all part of the specification.

[21:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1261s) Now, remember I said that all

[21:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1263s) conversations in AI have two sides, side

[21:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1265s) A and side B. And there's a bunch of

[21:06](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1266s) different ways according to the spec

[21:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1268s) that you can mix and match these. The

[21:09](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1269s) one we're the most familiar with is a

[21:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1272s) prompt speaking to a human. In other

[21:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1274s) words, you have an AI talking to a

[21:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1275s) human. This is like chat GBT. But you

[21:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1278s) can also have two AIs speaking to each

[21:20](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1280s) other. Where side A and side B are

[21:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1283s) actually both AI and side A is, you

[21:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1287s) know, writing thinking it's speaking to

[21:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1288s) a human and side B is writing thinking

[21:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1290s) it's speaking to a human and they're

[21:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1292s) both performing the operation together.

[21:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1294s) Now, this works wonderfully as built-in

[21:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1297s) eval built-in QA. I ask, you know, side

[21:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1300s) A to to generate some kind of asset. It

[21:43](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1303s) produces an image, let's say, and and

[21:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1304s) there's a watermark on it. It thinks it

[21:46](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1306s) looks great. So, it passes it to side B.

[21:48](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1308s) Side B looks at that and says, "Hey,

[21:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1310s) there's a watermark on there. What are

[21:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1311s) you doing?" Side A says, "Oh my

[21:52](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1312s) goodness, I'm so sorry about that.

[21:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1313s) You're absolutely right." And then it

[21:55](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1315s) regenerates it. So, those work really

[21:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1318s) great for built-in uh evalu.

[22:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1321s) And then we have a handler. A handler is

[22:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1325s) basically just code. So the simplest

[22:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1327s) form you could imagine a piece of code

[22:09](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1329s) runs on one side that just says continue

[22:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1331s) and you type something to it and it says

[22:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1332s) continue. You type something says

[22:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1334s) continue. So in that case you could

[22:16](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1336s) actually create an agent with no AI

[22:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1338s) involved at all where you have

[22:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1339s) deterministic code speaking to a human.

[22:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1341s) That's fine within our spec. And then uh

[22:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1344s) ultimately you could have an a prompt

[22:26](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1346s) and a human talking to each other where

[22:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1348s) one of them is actually a sub agent.

[22:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1351s) This gets a little bit confusing but

[22:33](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1353s) rest assured your coding agent will

[22:35](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1355s) figure out when you need to use these.

[22:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1357s) So handlers here's an example of a

[22:39](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1359s) handler. In this particular case the

[22:41](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1361s) handler is speaking uh deterministically

[22:43](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1363s) back to a human or even to an AI. In

[22:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1367s) this case we have uh two agents speaking

[22:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1369s) to each other. So you have a side A and

[22:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1371s) a side B. And here you can see that

[22:52](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1372s) we're defining which prompt each side

[22:55](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1375s) has. So we have the asset worker and

[22:57](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1377s) then the asset reviewer side of the

[22:59](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1379s) conversation.

[23:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1381s) Now sub aents sub aents are exactly what

[23:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1385s) they sound like. They are entire agents

[23:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1387s) with their own side A and side B. And

[23:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1390s) here you can see that we have the

[23:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1392s) calendar agent and in this case we have

[23:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1394s) two instances of the same agent. A one

[23:16](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1396s) is a work calendar and one is personal

[23:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1398s) calendar but ultimately they have the

[23:20](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1400s) same agent backing both of them the same

[23:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1403s) prompt the calendar agent.

[23:26](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1406s) Now parent hooks are a fascinating

[23:29](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1409s) concept in the specification. They allow

[23:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1412s) a child sub agent to get installed under

[23:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1414s) a parent and when they get installed

[23:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1417s) they automatically expose and modify the

[23:39](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1419s) hooks of the parent. This allows a

[23:42](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1422s) composition without having to do any

[23:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1425s) additional configuration or telling the

[23:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1427s) parent prompt, hey, by the way, you have

[23:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1429s) this subprompt that does something. No,

[23:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1431s) not necessary. Just installing the Gmail

[23:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1433s) agent, for example, automatically can

[23:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1436s) let the parent know how to use it. Hooks

[24:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1440s) are what they sound like. They are

[24:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1441s) deterministic events, stuff like filter

[24:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1443s) messages, before tool call, after update

[24:06](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1446s) message that run at very specific

[24:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1448s) moments in time throughout the life

[24:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1450s) cycle of the agent running. And these

[24:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1452s) are all defined in the specification.

[24:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1454s) Effects are basically scheduled code.

[24:17](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1457s) You write a chunk of code that needs to

[24:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1459s) occur at some other point. This could be

[24:22](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1462s) something simple like an alarm clock.

[24:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1464s) You could have a define effect for an

[24:26](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1466s) alarm clock or you could define an

[24:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1467s) effect to uh send an email. And when you

[24:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1470s) define this effect, you can then

[24:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1472s) schedule it to occur at some other time.

[24:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1474s) Obviously, you are often going to

[24:36](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1476s) schedule the effect inside of a tool

[24:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1478s) call. So you could have a tool call that

[24:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1480s) schedules an effect to happen at some

[24:41](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1481s) point in the future. This is effectively

[24:43](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1483s) like if I'm talking to Grockbot and I

[24:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1484s) say, "Hey, please, you know, don't don't

[24:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1487s) let me forget my my kids piano recital

[24:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1489s) tomorrow." Okay, great. No problem. It's

[24:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1491s) going to then set some sort of a

[24:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1493s) reminder to to trigger. This is how a

[24:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1496s) tool would be able to do something like

[24:57](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1497s) that within the specification. You have

[25:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1500s) an effect that you define and then later

[25:02](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1502s) you schedule it to occur at some point

[25:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1503s) in the future. Now every thread

[25:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1508s) according to the specification is a full

[25:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1510s) little environment. You could think

[25:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1511s) about each one like a little sandbox. It

[25:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1513s) has its own messages and and everything

[25:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1515s) to do with its messages stored there.

[25:17](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1517s) All of its own tools are stored there.

[25:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1519s) Its sub aents are stored there. It has

[25:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1521s) its own KV store. It has its own file

[25:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1524s) system. It even has an ability to write

[25:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1527s) its own code. and then run that code if

[25:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1530s) you choose to give it the ability to do

[25:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1532s) that, of course. So, let's take a little

[25:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1534s) bit of a look at threads. First, there's

[25:36](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1536s) code execution. Here you can see I can

[25:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1538s) write some code. It can be just a text

[25:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1540s) code. My agent can write some code,

[25:41](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1541s) store it to the file system that I just

[25:43](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1543s) told you exists. And then it could read

[25:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1545s) that code and run it. And then you

[25:48](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1548s) specify exactly what it has access to.

[25:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1550s) You can even say you don't have access

[25:52](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1552s) to the internet when you run it. That is

[25:55](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1555s) all part of the specification. Instead,

[25:57](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1557s) you say, "These are the things that you

[26:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1560s) can import. These are the things that

[26:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1561s) are allowed." And by doing this, you can

[26:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1563s) allow agents to have tremendous latitude

[26:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1567s) to operate within their own ecosystem.

[26:09](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1569s) You could also write uh an agent to use

[26:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1572s) code mode. The spec is very

[26:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1574s) unopinionated about things like that.

[26:16](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1576s) But personally, I use code mode all the

[26:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1578s) time with the standard agent

[26:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1579s) specification. By doing this, threads

[26:22](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1582s) can also use decision models. In this

[26:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1584s) case, we're using Typesafe AI's Jev to

[26:26](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1586s) determine if the customer is being, you

[26:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1588s) know, is happy or is upset. What's their

[26:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1590s) sentiment right now? Do we need to

[26:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1591s) escalate this to a human? That is part

[26:33](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1593s) of the runtime in the thread execution.

[26:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1597s) Threads can also expose endpoints. This

[26:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1600s) is part of the specification. It doesn't

[26:42](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1602s) have to, but a given agent should have

[26:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1605s) the ability to expose its own endpoints.

[26:48](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1608s) This would allow you to create something

[26:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1610s) like Grockbot that's completely open-

[26:52](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1612s) source where you can host it on your own

[26:55](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1615s) service and it would expose its own ooth

[26:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1618s) endpoints for example or host its own

[27:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1621s) API. So you could create something uh

[27:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1623s) like cloud artifacts

[27:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1627s) and then agents must be able to be

[27:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1630s) packed. The idea is you can pack these

[27:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1632s) down into something like an npm package

[27:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1634s) or literally an npm package, publish it,

[27:17](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1637s) and anyone can install it, anyone can

[27:20](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1640s) load it, and it just works.

[27:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1644s) The runtime is the magic behind it just

[27:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1647s) working. Of course, once you have an

[27:29](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1649s) agent in a runtime, there are explicit

[27:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1651s) rules in the specification for how it

[27:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1654s) needs to run. Now everything is really

[27:36](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1656s) unopinionated and it never says what

[27:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1658s) kinds of implementations you need to

[27:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1660s) have. What it says is how you handle the

[27:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1664s) different runtime states like how do you

[27:46](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1666s) handle a step of the agent, right? How

[27:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1669s) do you enforce safety across uh your run

[27:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1673s) code? How do you how do you store files?

[27:55](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1675s) So for example, there is a a basically a

[27:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1678s) thread state readad file. Well, it

[28:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1681s) doesn't say how the file should be read.

[28:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1683s) In our case, we actually host this on

[28:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1685s) Cloudflare in durable objects and we

[28:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1687s) implement read file as reading to a

[28:09](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1689s) database. There actually is no file

[28:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1691s) system, but the thread sees there being

[28:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1693s) a file system there. That is all part of

[28:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1695s) the runtime contract that is really,

[28:16](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1696s) really critical.

[28:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1699s) So, in the end, you can build almost any

[28:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1701s) agent system you can think of. You could

[28:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1703s) build really small ones or you could

[28:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1705s) build entire coding agents. So, we

[28:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1708s) actually did this a while ago. We built

[28:29](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1709s) a full coding agent made up of lots of

[28:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1711s) individual tiny little sub aents that

[28:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1714s) were all working together and it worked

[28:36](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1716s) great. And what was awesome about it is

[28:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1718s) because they were all standard agents,

[28:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1720s) we could go and install another standard

[28:42](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1722s) agent that was out in the ecosystem and

[28:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1725s) just add them to our coding agent like

[28:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1727s) you would add skills except these are

[28:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1729s) full agents with their own ability to

[28:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1731s) perform execution. But there's one more

[28:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1733s) thing I want to talk about. We're also

[28:55](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1735s) releasing standard agent builder. This

[28:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1738s) is the first public runtime for the

[29:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1741s) standard agent specification. We have

[29:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1743s) already been using this in production

[29:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1745s) for some time and it's working great.

[29:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1748s) You can clone this literally today onto

[29:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1751s) your machines and start using it. Then

[29:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1753s) you just ask your coding agent to create

[29:16](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1756s) some new agent for you and it will know

[29:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1759s) exactly how to do that. It knows it does

[29:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1761s) not need to reinvent every part of the

[29:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1763s) harness, but it knows exactly how to

[29:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1765s) define deterministically the pieces and

[29:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1767s) parts that need to be there. And then

[29:29](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1769s) you can run it at anywhere. You can run

[29:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1771s) it for free locally and if you push it,

[29:33](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1773s) we have a cloud you can push it to if

[29:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1774s) you want to put it in production. But

[29:36](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1776s) again, it's an open specification. You

[29:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1778s) can just point your coding agent at the

[29:39](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1779s) spec and say, "Build me a runtime for

[29:42](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1782s) this specification." We will even host

[29:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1784s) and put links on the spec site to your

[29:46](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1786s) runtime because we really do want this

[29:48](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1788s) to be an open ecosystem. Okay, with all

[29:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1791s) that, I want to do a little bit of demo

[29:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1793s) time. Earlier today, I had Claude Code

[29:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1796s) create a battery warranty claim. So,

[29:59](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1799s) this is very similar to the HVAC example

[30:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1800s) that we were doing. I gave it a full PDF

[30:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1803s) of the process that it needed to go

[30:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1805s) through. Now, I'm fast forwarding this

[30:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1807s) so that way you guys don't have to sit

[30:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1808s) here and watch while Opus does its work.

[30:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1810s) But right now it is reading um

[30:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1813s) everything that that PDF defines as part

[30:15](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1815s) of its process. Then it's going to write

[30:17](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1817s) specific tools and define specific

[30:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1819s) models in order to fulfill that specific

[30:22](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1822s) task. And then it's going to write those

[30:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1825s) in code. And while it's doing this, it

[30:29](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1829s) knows that it the architecture is

[30:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1831s) already solved for it. So it can do this

[30:33](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1833s) way way way faster than you're

[30:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1834s) traditionally used to. Um so you can see

[30:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1837s) here this is in real time now. So, we

[30:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1840s) fast forwarded. It's now telling me it's

[30:42](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1842s) done. Okay. So, in real time, it took 5

[30:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1844s) minutes and 21 seconds in order to

[30:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1847s) produce this agent. And I want to show

[30:48](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1848s) you what it actually made in 5 minutes

[30:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1849s) and 21 seconds. So, this is the file

[30:52](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1852s) system. Here you can see it created

[30:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1853s) these files. So, battery warranty agent

[30:56](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1856s) with prompts and then specific tools.

[30:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1858s) Check battery, escalate to lead. And

[31:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1860s) here you can see what the agent itself

[31:02](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1862s) looks like. Now, this is a side A is a

[31:04](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1864s) prompt and side B is a human. Here's the

[31:07](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1867s) actual prompt that it wrote. Here

[31:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1872s) is the model. So, it created a model

[31:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1874s) called warranty, which is Deepseek V4.1

[31:17](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1877s) flash. And in this case, it's also

[31:19](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1879s) showing uh the here we're looking at the

[31:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1881s) tools that it created in order to do its

[31:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1883s) job. Stuff like offer tradein, check

[31:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1885s) battery, uh report safety issue. All of

[31:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1888s) those tools are explicit tools just for

[31:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1891s) that process. They are not tools that

[31:33](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1893s) were created in any which way to go

[31:35](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1895s) check on the latest, you know, politics

[31:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1897s) or anything like that. These can only do

[31:39](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1899s) the work that they've been assigned.

[31:41](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1901s) Now, here it is inside of agent builder.

[31:43](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1903s) We have our actual battery warranty.

[31:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1905s) Then we can see all of the threads and

[31:47](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1907s) this is like the admin view into your

[31:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1909s) agent. Now, you can actually interact

[31:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1911s) with it directly here, although most of

[31:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1913s) your users are not going to be using the

[31:54](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1914s) agent here, but you get incredible

[31:57](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1917s) detail on everything that happened. So,

[32:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1920s) we can see all of the tools that were

[32:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1921s) called. We can see exactly the models,

[32:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1923s) exactly the cost, how many tokens were

[32:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1925s) sent, what our cash rate hit was, 94% in

[32:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1928s) this case. We can see the tools that we

[32:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1930s) sent. Um, so in this case, we sent these

[32:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1932s) six tools for it to choose from, and you

[32:14](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1934s) know, in in our particular case, it

[32:16](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1936s) shows one of those tools to call. Um,

[32:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1938s) you can also see the full request body,

[32:20](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1940s) every little detail about what was

[32:22](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1942s) actually sent to the LLM. This is super

[32:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1944s) valuable for when you're building out

[32:26](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1946s) your tool. And then ultimately, we can

[32:28](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1948s) see that it called the ship replacement

[32:30](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1950s) tool.

[32:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1952s) And then finally, the way your users are

[32:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1954s) actually going to interact with this is

[32:36](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1956s) manifold. In this case, we put a little

[32:37](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1957s) chatbot on a website. Now, this is the

[32:39](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1959s) actual agent behind the scenes because

[32:41](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1961s) an HTTP API and a websocket API are both

[32:45](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1965s) part of the specification. They both

[32:46](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1966s) need to be exposed. So, here we can see

[32:49](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1969s) that we could very easily build an

[32:51](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1971s) online support bot that is able to do

[32:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1973s) this. But again, we could expose the

[32:55](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1975s) same agent because it's a standard as an

[32:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1978s) MCP server. So if somebody is using our

[33:00](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1980s) website with chatgbt or something like

[33:02](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1982s) that, they could automatically have uh

[33:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1985s) their agent talk to our agent. So that

[33:09](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1989s) is a little brief preview of how the

[33:11](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1991s) standard agent builder works that's out

[33:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1993s) and available right now. So I know that

[33:16](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1996s) was a lot. It was a lot of information,

[33:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=1998s) but I hope you were able to get

[33:20](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2000s) something from that. We are really

[33:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2001s) excited to see people start building

[33:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2003s) runtimes. Um, if you would like to build

[33:25](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2005s) a runtime, build it in whatever language

[33:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2007s) you want, as long as it can execute the

[33:29](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2009s) TypeScript that's in the spec. Um, you

[33:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2011s) could build the runtime in Rust, you

[33:32](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2012s) could build it in Go, you could build in

[33:34](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2014s) whatever language you want. The runtime

[33:36](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2016s) is totally up for grabs as long as it

[33:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2018s) complies with the spec. Then start

[33:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2020s) building some agents. I'm super excited

[33:42](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2022s) to see an ecosystem of domain specific

[33:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2024s) agents emerge. Um, whatever you want to

[33:46](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2026s) build, we would love to see it. And then

[33:50](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2030s) try breaking the spec a little bit. Um,

[33:52](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2032s) we are by no means coming with a

[33:53](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2033s) finished solution. We're looking for

[33:54](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2034s) people to help push the spec forward.

[33:57](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2037s) This very much reminds me of the early

[33:58](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2038s) days of the web, right? When each

[34:01](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2041s) browser was trying to push its own

[34:03](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2043s) features. Hey, you should use Mozilla

[34:05](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2045s) because we have this crazy new thing

[34:08](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2048s) called JavaScript or something like that

[34:10](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2050s) that nobody else has. That's a little

[34:12](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2052s) bit like the world we're in right now.

[34:13](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2053s) And it took a ragtag group of spec

[34:16](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2056s) enthusiasts [clears throat] to get a

[34:18](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2058s) spec that was uh owned by the entire

[34:21](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2061s) world by the entire ecosystem and really

[34:23](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2063s) push the web forward. We want the same

[34:24](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2064s) thing to happen right now with agents.

[34:26](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2066s) So I hope that some people out there

[34:27](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2067s) would be excited to help us on that

[34:29](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2069s) journey and then start your coding

[34:31](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2071s) agent. Boot it up, add a skill to it and

[34:35](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2075s) start writing new stuff today. Okay.

[34:38](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2078s) Thank you very much. You can follow me

[34:40](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2080s) on X. You can go to

[34:41](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2081s) standardagentspec.org or to hear more.

[34:44](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2084s) All of this is available to you and I

[34:46](https://www.youtube.com/watch?v=3Krz7Rdd4JI&t=2086s) cannot wait to see what you all build.
