← All AI Engineer talks

AI Engineer World's Fair 2026

Tell the Robot What You Want — Sandhya Subramani, AWS

Read the talk

Tell the Robot What You Want: Scout’s Agent Layer

Sandhya Subramani shows how Strands Agents connects natural-language requests to existing robot capabilities—and how live execution exposes the gap between choosing an action and completing it.

From a talk by Sandhya Subramani

At a glance

Ideas worth remembering

  • An agent broadens how people request and combine robot capabilities. The agent selects what to do; an existing policy supplies how to do it, and missing physical capabilities remain missing.

  • The architecture separates agents, policy providers, execution backends, and hardware. Its proposed cloud-and-edge split combines cloud training with faster local execution, without establishing measured performance gains.

  • Natural-language fluency and completion messages are insufficient evidence of physical success. Scout’s complex-task response produces speech and a headlight change, while movement and recovery remain unreliable.

  • Manual navigation and conversational interactions can generate training episodes for later improvement. The demonstration establishes a way to collect data, rather than verified autonomous learning during use.

  • Camera-based conversation should retain the limits of the observation. Scout reports people counts, but its final answer also acknowledges that a low camera angle makes faces difficult to assess.

A conversation with a rover

Sandhya Subramani introduces Scout as her rover co-host, then moves from the presentation to its interface. Her opening request combines two actions in ordinary language: turn on the headlights and greet the audience. Scout takes a few seconds to respond. She describes a setup involving a Raspberry Pi, a SIM card, and a 4G connection. The demonstration depends on a networked command path.

Scout describes a presentation screen, stage lights, and audience seating. Subramani then asks how many people it sees, a question she says she never trained it to answer. Scout responds that it will inspect the front camera and reports two people: one near the speaker monitor at the back of the stage and another farther right. This demonstrates a conversational use of camera information beyond a specifically trained question-and-answer task. The count remains Scout’s reported interpretation, rather than an independently established measurement.

A request to spin 360 degrees adds movement to the exchange. After a delay, Subramani reports that Scout is turning and anticipates another description of its surroundings. The interaction brings together language, observation, and an existing movement capability, with a visible wait between the request and the reported action.

0:130:16
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:01 · section reference included

Give the agent a hardware tool

The mechanism behind Scout’s conversational behavior is an agent layer built with Strands Agents, which Subramani identifies as an open-source AWS framework. The robot already has actions it can perform. The added layer interprets a request and orchestrates the tools needed to carry it out. Her analogy is direct: just as a software agent receives software tools, it can receive a robot as a hardware tool exposing preset functions or programmable policies.

The agent’s decision is which policy to invoke and when. That makes a fixed collection of capabilities accessible through a wider range of natural-language requests. It does not itself supply missing physical skills. Subramani makes that boundary explicit in her setup example: a request to pick up a red cube should work only if the robot already has that capability.

She presents the agent wiring as five lines of code: import the Strands agent, make the robot tool available, assign it to the agent’s tools, and issue the task. The small integration surface depends on the robot tool and its underlying capabilities already existing. The red-cube example illustrates that interface; it is not a demonstrated grasping task.

3:183:26
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:18 · section reference included

Separate perception, conversation, and voice

Scout’s design includes three Strands agents. A thinker agent continually assesses the environment and considers what to do next. A communication agent connects to Telegram and a web app, allowing Subramani to converse with Scout and request actions. This separates ongoing environmental assessment from the channel through which a person gives instructions.

The third agent handles voice interaction, but Subramani has disabled it for the presentation. It would otherwise interpret her stage speech as speech directed at Scout and repeatedly interrupt her. Although she describes the three agents as designed to work together, the live configuration deliberately reduces that interaction. The practical issue is deciding when a person is addressing the robot, not simply whether the robot can understand speech.

5:265:28
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:20 · section reference included

Commands travel down; observations travel up

Subramani says the package supports more than 40 robots across eight categories through robot tool calls. She organizes the architecture into four layers: the agent, the policy provider, the execution backend, and the physical hardware. The flow is bidirectional. Instructions descend toward the robot, while observations return upward to inform the agent.

At the top, the Strands agent receives a request and selects a policy. The policy provider supplies the learned behavior, and Subramani describes a training process that collects data, trains on it, and creates additional simulation data to produce a VLA model. The agent invokes the relevant policy for the question or command. This keeps task selection separate from the training that gives the robot an executable behavior.

The backend provides the environment or interface on which the policy runs, whether a simulation environment or a hardware environment. Physical output occurs at the robot. During this explanation, Subramani interrupts herself to discuss Scout falling and asks it to move back. She expects it to tolerate a fall and resume, but those expectations are not a demonstrated recovery guarantee. The interruption makes the physical endpoint of the architecture tangible: selecting a policy still leaves the robot to execute it under real conditions.

6:476:50
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

6:47 · section reference included

Split training and execution across cloud and edge

The proposed deployment places Strands Agents on both the cloud and the edge. Subramani describes cloud-side training of VLA models and policies using AgentCore, with direct edge-side invocation to make robot execution faster. Strands can decide which part to call. The motivation is to combine the capacity needed for substantial training with a shorter runtime path for physical actions; the talk does not provide latency measurements or a detailed placement rule.

She connects this arrangement to a learning loop: the robot collects information, that information can support further training, and the resulting system should still execute quickly at runtime. Her central division of responsibility is that the agent decides what to do and the policy decides how to do it. As she again checks whether Scout can recover its posture, that distinction also marks a limit: competent task selection does not establish reliable balance or movement.

8:559:01
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:55 · section reference included

An intermediate step toward broader robot policies

Subramani contrasts robots programmed for a particular set of autonomous tasks with a possible future in which VLA models become as broad and capable as large language models. In that future, she suggests, a single model might provide enough capability to avoid repeated task-specific adaptation. This is a forecast about what policies could become, rather than a capability established by Scout.

Until then, she presents agents over existing policies as a useful intermediate step. Existing VLA models and policies still need adaptation, but an agent can make their capabilities accessible through a broader set of requests. Scout falls again during the discussion, and Subramani tries to get it upright and stopped before returning to the interface. The proposed future and the present robot’s limitations remain visibly separate.

10:1310:16
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:13 · section reference included

A complex request produces an uneven performance

Back in the demonstration, Subramani asks Scout to do something complex. Scout produces speech about a completed 360-degree turn and being safely onstage, then announces a signature performance. Subramani observes that it is not doing anything and asks it to act. The concrete change she reports is that it turns off its headlights. Fluent narration does not, in this exchange, establish completion of the requested performance.

The interface exposes a tool invocation labeled “rover speak,” which Subramani identifies as the function chosen in response to the request. She thinks Scout should also have attempted an action and attributes a fall to that attempt, though the precise action is not established. She has seen it perform a dance before, but that earlier behavior does not materialize reliably here. The useful distinction is between a selected tool, its verbal output, and a successfully completed physical task.

11:5912:03
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:59 · section reference included

Use interactions to build the next training set

Scout also serves as a data-collection platform. Subramani can move it manually, direct its navigation, and create training episodes. These episodes can capture how it responds to questions and the reasoning it reports, providing material for subsequent improvement. Autonomous behavior and manual guidance both contribute to the experiment. Collecting those records is a concrete step toward training; it does not by itself demonstrate that the robot improves during the interaction.

In the configuration, Strands Agents supplies the harness SDK and an Anthropic Claude model supplies the language-model component; the exact model version is not reliably established. A system prompt describes what Scout should do, its rules, and the purposes of the available capabilities. Those descriptions help the agent decide which tool to invoke for a request. The voice component uses OpenAI Realtime, and Subramani says she has added safety and guardrail information, without detailing the enforcement mechanisms.

13:1613:19
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:16 · section reference included

Telegram connects a request to movement and a qualified answer

The final demonstration uses Telegram, which Subramani also uses to communicate with Scout when she is away from home. She asks it to spin, analyze the room, and identify the best-looking person. The playful request combines movement, perception, and a subjective judgment. She warns that the answer is unpredictable and may be biased. Scout acknowledges the request and appears to turn, but a follow-up request to spin farther does not produce the additional movement she expects.

Scout then reports that its spin is complete and estimates six to seven people, describing people near the front, others in the audience, and someone onstage. These are the robot’s scene descriptions, not a verified count or proof that the entire room was inspected. Its response to the appearance question includes a useful perceptual limitation: from its low, ground-level viewpoint, faces are difficult to judge. It instead awards style points to the person onstage for their stride and the blue curtain backdrop.

Subramani closes by joking that Scout can provide a confidence boost when she is the only person in the room, then thanks the audience. The final exchange demonstrates a remote conversational interface that can request physical action and return an interpretation of camera input, while the answer itself acknowledges that the robot’s viewpoint limits what it can assess.

14:5214:54
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

14:52 · section reference included

Read the complete timestamped transcript
  1. 0:01

    [music]

  2. 0:13

    Hello everyone. My name is Sandy and

  3. 0:16

    meet my co-host today, Scout. This is my

  4. 0:21

    friendly rover. And one would think that

  5. 0:25

    rovers can't really think for

  6. 0:28

    themselves, right? We have to tell them

  7. 0:29

    what to do or we have to very

  8. 0:31

    specifically program them on how to

  9. 0:34

    think. But this little guy here actually

  10. 0:37

    has a brain and he can think for

  11. 0:40

    himself. Let me show you my screen. Oh

  12. 0:43

    no, it's going to the wrong screen. I'm

  13. 0:44

    going to see how I can stop this and I'm

  14. 0:48

    going to see how I can move to my

  15. 0:49

    screen. Um,

  16. 0:52

    give me just a second. I'm going to end

  17. 0:54

    show and then we get to this. So this is

  18. 0:57

    what Scout here is looking at. And Scout

  19. 1:01

    here has a small little brain. And Scout

  20. 1:05

    can understand what I'm saying in

  21. 1:07

    natural language. For example, if you

  22. 1:10

    can see my screen here, if I say, "Hey

  23. 1:13

    Scout," I'm going to type to him. Say,

  24. 1:15

    "Hey Scout,

  25. 1:17

    turn on your headlights

  26. 1:21

    and say hi to everyone.

  27. 1:27

    he is actually going to be able to

  28. 1:29

    understand and do those actions. But how

  29. 1:32

    is he able to do these things, right?

  30. 1:34

    It's going to take him a couple of

  31. 1:36

    seconds to think about it because how

  32. 1:38

    this has been set up is he is working on

  33. 1:42

    with a Raspberry Pi installed and that

  34. 1:44

    Raspberry Pi is actually in a small

  35. 1:47

    little location in New York City and

  36. 1:50

    he's got a SIM card here which is then

  37. 1:52

    connecting to that to that Raspberry Pi

  38. 1:55

    and then he's getting signals. So, this

  39. 1:57

    is via 4G connection. And so, he's like,

  40. 1:59

    "Oh, hey, on it." And if you can see,

  41. 2:01

    you know what? I'm going to tell him,

  42. 2:02

    "Spin around." And oh, no, he's actually

  43. 2:05

    speaking to me. He's like, "I see the

  44. 2:07

    stage and it's looking great. Big

  45. 2:09

    presentation screen to the left, bright

  46. 2:11

    stage lights, and rows of seats for the

  47. 2:13

    audience.

  48. 2:15

    How How many people do you see?

  49. 2:21

    I've never trained him to answer this

  50. 2:23

    question, but he's Let's see if he's get

  51. 2:26

    getting it.

  52. 2:28

    He's thinking for like a second or two.

  53. 2:32

    Let me take a good look from the front

  54. 2:35

    camera. I see two people. One near the

  55. 2:37

    speaker monitor set up at the back of

  56. 2:39

    the stage and another person further

  57. 2:41

    right. Nah. spin 360

  58. 2:51

    and he's also saying is this session

  59. 2:52

    about to start right so he's going to

  60. 2:55

    spin 360 any second now and then he's

  61. 2:58

    probably going to be like oh wow I did

  62. 3:01

    so this little robot here is a next

  63. 3:05

    generation of robot where ah there we go

  64. 3:10

    he is spinning 360 now and he's probably

  65. 3:13

    going to tell me what he's seeing

  66. 3:18

    and he's saying let's spin. Right? So

  67. 3:20

    this new generation of robots is to it's

  68. 3:24

    different from our traditional robot

  69. 3:26

    training because I have given this guy a

  70. 3:29

    little brain. And what do I mean by I've

  71. 3:32

    given him a brain? I've given this robot

  72. 3:35

    an agentic layer and I've given it it's

  73. 3:38

    called strands agents which is an

  74. 3:40

    open-source framework which was built by

  75. 3:43

    AWS and I'm going to quickly go back to

  76. 3:46

    my slide deck

  77. 3:49

    we can see it right and so here what

  78. 3:51

    happens is we have these existing tools

  79. 3:55

    that the robot can do he can take

  80. 3:58

    certain actions by himself but only

  81. 4:00

    those actions by himself so what we can

  82. 4:03

    do is we can add a layer of LLM or even

  83. 4:06

    better add a layer of agent to it so

  84. 4:09

    that the agent orchestrates which tool

  85. 4:12

    to call and how to really get the robot

  86. 4:15

    to start doing the things we want. So in

  87. 4:18

    traditional software with traditional AI

  88. 4:21

    machine uh like AI engineering we can

  89. 4:23

    give agents software tools. Similarly,

  90. 4:26

    we can give the same AI agent a hardware

  91. 4:31

    tool called a robot which has access to

  92. 4:34

    preset functions or programmable

  93. 4:36

    policies and then the agent can decide

  94. 4:40

    which policy to implement when. So all

  95. 4:42

    it takes is one robot agent for us to be

  96. 4:46

    able to do new innumerous tasks and have

  97. 4:49

    it understand what we're teaching it in

  98. 4:52

    natural language. So how do we get

  99. 4:56

    started with it? All it takes is five

  100. 4:58

    lines of code. This is through uh the

  101. 5:02

    agent harness called strands. And all we

  102. 5:04

    have to do is import the strands agent

  103. 5:08

    and call the robot tool. And we say ro

  104. 5:11

    tools equals the robot and then we say

  105. 5:14

    pick up the red cube and should be able

  106. 5:15

    to pick up a red cube assuming that the

  107. 5:18

    robot has that capability. Yeah. Now

  108. 5:20

    he's seen someone and he's like oh let

  109. 5:22

    me go towards that person. So he gets

  110. 5:23

    pretty excited. This guy is pretty

  111. 5:26

    special because he doesn't have just one

  112. 5:28

    agent. He's got three different agents.

  113. 5:30

    All three of them are strands and all

  114. 5:32

    three of them are working

  115. 5:34

    simultaneously. One of them is the

  116. 5:36

    thinker agent and that's the part of him

  117. 5:38

    that's constantly thinking and assessing

  118. 5:40

    the environment and like what do I do

  119. 5:42

    next? And that guy's that part of his

  120. 5:44

    brain is constantly thinking. Then

  121. 5:46

    there's the other communication part of

  122. 5:48

    it where and I'm going to show you that

  123. 5:50

    in a bit, right? and I've connected him

  124. 5:53

    to my telegram app as well as to my web

  125. 5:56

    app. And so he is able to have a

  126. 5:58

    conversation with me in natural language

  127. 6:00

    and then take actions based on what I am

  128. 6:02

    telling him to do. Apart from him just

  129. 6:05

    perceiving and thinking and figuring out

  130. 6:07

    what he wants to do. And the third

  131. 6:09

    agent, the third type of agent that he's

  132. 6:11

    got access to is a voice agent. I did

  133. 6:13

    have to disable it because every time I

  134. 6:15

    speak, he's going to think I'm speaking

  135. 6:17

    to him and so he's going to keep

  136. 6:18

    chatting away with me and it's just not

  137. 6:21

    going to be fun because we're going to

  138. 6:22

    have our co-host interrupting me all the

  139. 6:24

    time. So, I've disabled that feature for

  140. 6:27

    the time being. But essentially all

  141. 6:30

    three of these agents work in tandem

  142. 6:33

    with this one robot and thereby this

  143. 6:36

    gives him the ability to do way more

  144. 6:38

    than what just what he's been trained to

  145. 6:41

    do more than just the policies that he's

  146. 6:44

    learned. Now

  147. 6:47

    what is a quick overview on this trans

  148. 6:50

    package itself? This turns package has

  149. 6:53

    more than supports more than 40

  150. 6:55

    different robots under eight categories.

  151. 6:58

    And all of these are just simple robot

  152. 7:01

    tool calls. And how is this all set up?

  153. 7:04

    Four different layers. The first one is

  154. 7:07

    the agent layer, the topmost one. And

  155. 7:09

    there are two parts to this. One is how

  156. 7:11

    the actions go in and the second is how

  157. 7:14

    it observes and the observations go up.

  158. 7:17

    So if you notice it's very birectional.

  159. 7:20

    So first when we give it an instruction

  160. 7:22

    we would be talking to this trans agent

  161. 7:25

    which is the agentic layer that would

  162. 7:27

    then decide which policy to call and the

  163. 7:31

    policy provider again stands agent

  164. 7:33

    supports a bunch of different policy

  165. 7:35

    providers and we can then train our

  166. 7:38

    policy based on our traditional robot

  167. 7:40

    training. So in our policies we would

  168. 7:42

    collect data and then we would train on

  169. 7:44

    it and we would sim create more

  170. 7:46

    simulation data and that policy then

  171. 7:49

    becomes a VLA model which then the robot

  172. 7:53

    would have access to strand agents would

  173. 7:55

    have access to and then it would invoke

  174. 7:58

    that specific policy based on the

  175. 8:00

    question that we're asking it or the

  176. 8:01

    command that we're giving it and that

  177. 8:04

    policy needs to sit somewhere right so

  178. 8:06

    that sits in the back end which could be

  179. 8:08

    your simulation environment or it could

  180. 8:11

    be a real hardware chip, your hardware

  181. 8:13

    environment. That is the back end on

  182. 8:15

    which that is the interface on which the

  183. 8:18

    policy is running. And finally, the

  184. 8:21

    output actually takes place in the

  185. 8:23

    physical hardware which is the robot.

  186. 8:25

    And so the robot ah see so now it's

  187. 8:28

    responding this even if he falls down

  188. 8:30

    he's supposed to be fine. He technically

  189. 8:32

    shouldn't um he technically shouldn't uh

  190. 8:36

    get hurt. He should be able to pick back

  191. 8:38

    up from where he um stops. Ah, okay. So,

  192. 8:42

    I'm telling him to go back a bit. Back

  193. 8:45

    off. Let's see if he actually backs off.

  194. 8:48

    Um, so that is the four layers of how to

  195. 8:53

    get started with building this, right?

  196. 8:55

    And what's happening under the hood,

  197. 8:57

    like a more picturesic view of what's

  198. 9:00

    the architecture of what's going on

  199. 9:01

    under the hood. We want everything is

  200. 9:04

    basically strands agents on the edge as

  201. 9:07

    well as on the cloud. We want to be able

  202. 9:10

    to train the VLA and the policies on

  203. 9:13

    with using agent core. Um and we want

  204. 9:16

    that to happen on the cloud but we also

  205. 9:18

    want to be able to call it directly on

  206. 9:21

    edge so that our robot can uh execute

  207. 9:26

    functions and policies faster. So this

  208. 9:28

    is sort of like a hybrid model where a

  209. 9:30

    part of it happens on the cloud and

  210. 9:33

    another part of it happens on the edge

  211. 9:35

    and strands can decide when to call

  212. 9:38

    which part of it. And so this helps with

  213. 9:41

    massive amounts of training as well when

  214. 9:43

    it's constantly collecting information

  215. 9:45

    and it's train able to train on that

  216. 9:47

    information and learn from itself but

  217. 9:49

    also just execute at runtime really

  218. 9:52

    really quickly. Now, like I said, the

  219. 9:55

    agent decides what to do and the policy

  220. 9:59

    decides how it should be done. But he's

  221. 10:01

    pretty smart. He should be able to pick

  222. 10:03

    himself back up if he's not fully fallen

  223. 10:05

    down. And he should be able to continue

  224. 10:07

    moving along.

  225. 10:10

    So, I think he's okay. Now, where does

  226. 10:13

    this leave us? And why is this so

  227. 10:16

    special? We started off with very

  228. 10:20

    traditional robots. Robots have existed

  229. 10:23

    since forever, right? And they've always

  230. 10:26

    just been programmed, pre-programmed to

  231. 10:28

    do to autom be automated and do a

  232. 10:31

    certain set of tasks autonomously.

  233. 10:34

    But there is a future in this world

  234. 10:38

    where this these robot policies, these

  235. 10:41

    VLA models could be so advanced that we

  236. 10:45

    wouldn't even need to do this. They

  237. 10:47

    could be as large as our large language

  238. 10:50

    models. So that ah wait hang on he's

  239. 10:53

    falling back again.

  240. 10:55

    I'm gonna see if I can get him to move

  241. 10:57

    back up.

  242. 10:59

    Good boy. Stop.

  243. 11:02

    Then he's fallen off again. Um we get to

  244. 11:05

    a point where these large language the

  245. 11:08

    the VA models could be as large and as

  246. 11:11

    amazing as our larger language models

  247. 11:13

    and they know they have all the

  248. 11:15

    information in the world and we wouldn't

  249. 11:17

    even have to do this. we might just have

  250. 11:19

    to feed in one simple model and then we

  251. 11:21

    could give it to him and then he would

  252. 11:23

    know exactly what to do. But until that

  253. 11:25

    point where we don't have to fine-tune

  254. 11:27

    on top of existing VAS and existing

  255. 11:30

    policies, we can do this. And this is a

  256. 11:33

    stepping stone towards a future where we

  257. 11:38

    don't need to train robots anymore. So

  258. 11:40

    now if we wanted to do more things than

  259. 11:43

    just the tasks it's trained on, give it

  260. 11:45

    an agent and see what it can do. And so

  261. 11:48

    let me quickly go back to my demo and

  262. 11:51

    I'm going to show you how it's actually

  263. 11:53

    working.

  264. 11:59

    Okay. So this is my so this is strand

  265. 12:03

    here. This is scout here. And I've been

  266. 12:05

    telling him to do a bunch of things. So

  267. 12:07

    I can say, "Hey, do something

  268. 12:11

    complex."

  269. 12:15

    That's not complex. He's going to be

  270. 12:16

    thinking now. Ah, he's going to fall

  271. 12:18

    off.

  272. 12:21

    So he's saying, "Let's spin. Full 360.

  273. 12:24

    Done. Still safely on the stage. I can

  274. 12:26

    see the bright stage lights and the

  275. 12:28

    audience seating area." All good. What's

  276. 12:31

    there? A challenge.

  277. 12:34

    >> So he's speaking. I called this my

  278. 12:36

    signature performance,

  279. 12:40

    >> but he's not doing anything. What are

  280. 12:42

    you doing?

  281. 12:45

    He clearly seems to be speaking, but

  282. 12:47

    what are you doing? Please do something.

  283. 12:50

    He just turned off his headlines. Cool.

  284. 12:53

    Okay, now he's calling. So, do you see

  285. 12:55

    it saying calling rover speak, which was

  286. 12:57

    the function that it called because I

  287. 12:59

    said do something complex. So now it

  288. 13:01

    spoke, but now I think it should have

  289. 13:03

    been attempting to do something and it

  290. 13:05

    fell off because it tried doing

  291. 13:06

    something.

  292. 13:08

    I've actually seen it do like a funky

  293. 13:10

    dance, like this funky dance move. But

  294. 13:14

    he's got a mind of his own right now.

  295. 13:16

    What's going on under the hood here?

  296. 13:19

    Couple of things. The first thing is

  297. 13:21

    here, I can use this. What is the point

  298. 13:23

    of creating him? I can use him to create

  299. 13:25

    my data sets because I'm able to also

  300. 13:29

    manually move him. I will get him to

  301. 13:31

    navigate in the direction that I want

  302. 13:33

    him to and then I can create training

  303. 13:36

    episodes and I can get information on

  304. 13:38

    how he's responding and how he's

  305. 13:40

    reasoning based on the questions that I

  306. 13:42

    ask. And this is super good information

  307. 13:44

    for me to then be able to make him do a

  308. 13:47

    better job of it. So that's one part of

  309. 13:50

    this whole process and this experiment

  310. 13:52

    of getting of giving him his own

  311. 13:54

    autonomy and getting him to do things so

  312. 13:56

    that I can create more data but also

  313. 14:00

    apart from that uh this is my

  314. 14:03

    configuration. So over here under the

  315. 14:05

    hood strands agents which is your

  316. 14:08

    harness SDK is using currently anthropic

  317. 14:12

    claude opus 4.8 under the hood. So that

  318. 14:14

    is the brain and then this is my simple

  319. 14:17

    prompt where system prompt where I'm

  320. 14:19

    telling it what it's supposed to be

  321. 14:21

    doing and I'm telling it all of the

  322. 14:23

    rules and I'm also giving it access to

  323. 14:25

    all of the rules that it's already got.

  324. 14:27

    So I'm telling it what each of these

  325. 14:29

    rules are meant for. And so that's how

  326. 14:33

    strand decides which tool to invoke

  327. 14:36

    based on what I'm asking it to do. And

  328. 14:38

    the voice that it's using is the one of

  329. 14:41

    open AI real time. And I've also given

  330. 14:44

    it more information for it to be able to

  331. 14:48

    like just safety and guard rails to

  332. 14:50

    ensure that it's doing really well. Now

  333. 14:52

    it's this is these are two of the

  334. 14:54

    agents. The other thing that it can do

  335. 14:56

    is also chat with me on Telegram. This

  336. 15:00

    is amazing because when I'm not at home

  337. 15:02

    and I still want to get it to speak to

  338. 15:04

    me, I can say, "Hey, scout.

  339. 15:07

    Who is turn around uh spin around

  340. 15:12

    analyze?" Uh-uh. Don't fall off. Analyze

  341. 15:16

    the room and tell me who is the best

  342. 15:21

    looking person. This is always a hit or

  343. 15:23

    miss. Don't blame me if if Scout decides

  344. 15:26

    to be biased. I tried playing with this

  345. 15:28

    because it makes me feel like Snow White

  346. 15:31

    um and the queen saying mirror mirror on

  347. 15:33

    the wall who is the fairest of them all

  348. 15:35

    and so let's see if Strand can give us

  349. 15:38

    that. So it's saying haha on it on there

  350. 15:40

    spinning around to scope the room. Is he

  351. 15:43

    spinning? He is. Looks like he's making

  352. 15:45

    and let's look at what he's looking at

  353. 15:47

    now. He's still looking at the stage.

  354. 15:49

    This is the other miller. He's looking

  355. 15:50

    at me. Hi. Am I the prettiest? Oh, you

  356. 15:53

    flatter me. But no, turn again. Spin

  357. 15:55

    some more, please.

  358. 15:57

    He's decided not to spin more. Let's see

  359. 16:00

    what he says.

  360. 16:07

    Spin complete. Here is my analysis of

  361. 16:09

    the room. You can see my screen, right?

  362. 16:11

    I have no way of zooming this in. Um,

  363. 16:14

    spotted six to seven people total. A

  364. 16:16

    couple seated front center near the

  365. 16:18

    bright stage, right? A few more in the

  366. 16:20

    audience. One person a dark outfit on

  367. 16:22

    the stage. The rocking khaki jeans and

  368. 16:25

    sneakers. Thank you very much. Oh, no,

  369. 16:27

    no, no. The person in front of me, cocky

  370. 16:29

    jeans and sneakers, clearly walking with

  371. 16:33

    purpose on stage. Uh, best looking.

  372. 16:36

    Honestly, from my low angle ground view,

  373. 16:38

    it's tough to tell faces, but the person

  374. 16:41

    on the stage right now gets style points

  375. 16:43

    for the confidence stride and the

  376. 16:45

    dramatic blue curtain backdrop. Thank

  377. 16:48

    you very much. Every time I need a

  378. 16:49

    confidence boost, I can be the only

  379. 16:51

    person in the room and ask this guy

  380. 16:53

    who's the prettiest of them all, and he

  381. 16:56

    will always choose me as the answer.

  382. 17:01

    [laughter]

  383. 17:02

    Thank you very much.

  384. 17:18

    >> [music]