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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Read the complete timestamped transcript
- 0:01
[music]
- 0:13
Hello everyone. My name is Sandy and
- 0:16
meet my co-host today, Scout. This is my
- 0:21
friendly rover. And one would think that
- 0:25
rovers can't really think for
- 0:28
themselves, right? We have to tell them
- 0:29
what to do or we have to very
- 0:31
specifically program them on how to
- 0:34
think. But this little guy here actually
- 0:37
has a brain and he can think for
- 0:40
himself. Let me show you my screen. Oh
- 0:43
no, it's going to the wrong screen. I'm
- 0:44
going to see how I can stop this and I'm
- 0:48
going to see how I can move to my
- 0:49
screen. Um,
- 0:52
give me just a second. I'm going to end
- 0:54
show and then we get to this. So this is
- 0:57
what Scout here is looking at. And Scout
- 1:01
here has a small little brain. And Scout
- 1:05
can understand what I'm saying in
- 1:07
natural language. For example, if you
- 1:10
can see my screen here, if I say, "Hey
- 1:13
Scout," I'm going to type to him. Say,
- 1:15
"Hey Scout,
- 1:17
turn on your headlights
- 1:21
and say hi to everyone.
- 1:27
he is actually going to be able to
- 1:29
understand and do those actions. But how
- 1:32
is he able to do these things, right?
- 1:34
It's going to take him a couple of
- 1:36
seconds to think about it because how
- 1:38
this has been set up is he is working on
- 1:42
with a Raspberry Pi installed and that
- 1:44
Raspberry Pi is actually in a small
- 1:47
little location in New York City and
- 1:50
he's got a SIM card here which is then
- 1:52
connecting to that to that Raspberry Pi
- 1:55
and then he's getting signals. So, this
- 1:57
is via 4G connection. And so, he's like,
- 1:59
"Oh, hey, on it." And if you can see,
- 2:01
you know what? I'm going to tell him,
- 2:02
"Spin around." And oh, no, he's actually
- 2:05
speaking to me. He's like, "I see the
- 2:07
stage and it's looking great. Big
- 2:09
presentation screen to the left, bright
- 2:11
stage lights, and rows of seats for the
- 2:13
audience.
- 2:15
How How many people do you see?
- 2:21
I've never trained him to answer this
- 2:23
question, but he's Let's see if he's get
- 2:26
getting it.
- 2:28
He's thinking for like a second or two.
- 2:32
Let me take a good look from the front
- 2:35
camera. I see two people. One near the
- 2:37
speaker monitor set up at the back of
- 2:39
the stage and another person further
- 2:41
right. Nah. spin 360
- 2:51
and he's also saying is this session
- 2:52
about to start right so he's going to
- 2:55
spin 360 any second now and then he's
- 2:58
probably going to be like oh wow I did
- 3:01
so this little robot here is a next
- 3:05
generation of robot where ah there we go
- 3:10
he is spinning 360 now and he's probably
- 3:13
going to tell me what he's seeing
- 3:18
and he's saying let's spin. Right? So
- 3:20
this new generation of robots is to it's
- 3:24
different from our traditional robot
- 3:26
training because I have given this guy a
- 3:29
little brain. And what do I mean by I've
- 3:32
given him a brain? I've given this robot
- 3:35
an agentic layer and I've given it it's
- 3:38
called strands agents which is an
- 3:40
open-source framework which was built by
- 3:43
AWS and I'm going to quickly go back to
- 3:46
my slide deck
- 3:49
we can see it right and so here what
- 3:51
happens is we have these existing tools
- 3:55
that the robot can do he can take
- 3:58
certain actions by himself but only
- 4:00
those actions by himself so what we can
- 4:03
do is we can add a layer of LLM or even
- 4:06
better add a layer of agent to it so
- 4:09
that the agent orchestrates which tool
- 4:12
to call and how to really get the robot
- 4:15
to start doing the things we want. So in
- 4:18
traditional software with traditional AI
- 4:21
machine uh like AI engineering we can
- 4:23
give agents software tools. Similarly,
- 4:26
we can give the same AI agent a hardware
- 4:31
tool called a robot which has access to
- 4:34
preset functions or programmable
- 4:36
policies and then the agent can decide
- 4:40
which policy to implement when. So all
- 4:42
it takes is one robot agent for us to be
- 4:46
able to do new innumerous tasks and have
- 4:49
it understand what we're teaching it in
- 4:52
natural language. So how do we get
- 4:56
started with it? All it takes is five
- 4:58
lines of code. This is through uh the
- 5:02
agent harness called strands. And all we
- 5:04
have to do is import the strands agent
- 5:08
and call the robot tool. And we say ro
- 5:11
tools equals the robot and then we say
- 5:14
pick up the red cube and should be able
- 5:15
to pick up a red cube assuming that the
- 5:18
robot has that capability. Yeah. Now
- 5:20
he's seen someone and he's like oh let
- 5:22
me go towards that person. So he gets
- 5:23
pretty excited. This guy is pretty
- 5:26
special because he doesn't have just one
- 5:28
agent. He's got three different agents.
- 5:30
All three of them are strands and all
- 5:32
three of them are working
- 5:34
simultaneously. One of them is the
- 5:36
thinker agent and that's the part of him
- 5:38
that's constantly thinking and assessing
- 5:40
the environment and like what do I do
- 5:42
next? And that guy's that part of his
- 5:44
brain is constantly thinking. Then
- 5:46
there's the other communication part of
- 5:48
it where and I'm going to show you that
- 5:50
in a bit, right? and I've connected him
- 5:53
to my telegram app as well as to my web
- 5:56
app. And so he is able to have a
- 5:58
conversation with me in natural language
- 6:00
and then take actions based on what I am
- 6:02
telling him to do. Apart from him just
- 6:05
perceiving and thinking and figuring out
- 6:07
what he wants to do. And the third
- 6:09
agent, the third type of agent that he's
- 6:11
got access to is a voice agent. I did
- 6:13
have to disable it because every time I
- 6:15
speak, he's going to think I'm speaking
- 6:17
to him and so he's going to keep
- 6:18
chatting away with me and it's just not
- 6:21
going to be fun because we're going to
- 6:22
have our co-host interrupting me all the
- 6:24
time. So, I've disabled that feature for
- 6:27
the time being. But essentially all
- 6:30
three of these agents work in tandem
- 6:33
with this one robot and thereby this
- 6:36
gives him the ability to do way more
- 6:38
than what just what he's been trained to
- 6:41
do more than just the policies that he's
- 6:44
learned. Now
- 6:47
what is a quick overview on this trans
- 6:50
package itself? This turns package has
- 6:53
more than supports more than 40
- 6:55
different robots under eight categories.
- 6:58
And all of these are just simple robot
- 7:01
tool calls. And how is this all set up?
- 7:04
Four different layers. The first one is
- 7:07
the agent layer, the topmost one. And
- 7:09
there are two parts to this. One is how
- 7:11
the actions go in and the second is how
- 7:14
it observes and the observations go up.
- 7:17
So if you notice it's very birectional.
- 7:20
So first when we give it an instruction
- 7:22
we would be talking to this trans agent
- 7:25
which is the agentic layer that would
- 7:27
then decide which policy to call and the
- 7:31
policy provider again stands agent
- 7:33
supports a bunch of different policy
- 7:35
providers and we can then train our
- 7:38
policy based on our traditional robot
- 7:40
training. So in our policies we would
- 7:42
collect data and then we would train on
- 7:44
it and we would sim create more
- 7:46
simulation data and that policy then
- 7:49
becomes a VLA model which then the robot
- 7:53
would have access to strand agents would
- 7:55
have access to and then it would invoke
- 7:58
that specific policy based on the
- 8:00
question that we're asking it or the
- 8:01
command that we're giving it and that
- 8:04
policy needs to sit somewhere right so
- 8:06
that sits in the back end which could be
- 8:08
your simulation environment or it could
- 8:11
be a real hardware chip, your hardware
- 8:13
environment. That is the back end on
- 8:15
which that is the interface on which the
- 8:18
policy is running. And finally, the
- 8:21
output actually takes place in the
- 8:23
physical hardware which is the robot.
- 8:25
And so the robot ah see so now it's
- 8:28
responding this even if he falls down
- 8:30
he's supposed to be fine. He technically
- 8:32
shouldn't um he technically shouldn't uh
- 8:36
get hurt. He should be able to pick back
- 8:38
up from where he um stops. Ah, okay. So,
- 8:42
I'm telling him to go back a bit. Back
- 8:45
off. Let's see if he actually backs off.
- 8:48
Um, so that is the four layers of how to
- 8:53
get started with building this, right?
- 8:55
And what's happening under the hood,
- 8:57
like a more picturesic view of what's
- 9:00
the architecture of what's going on
- 9:01
under the hood. We want everything is
- 9:04
basically strands agents on the edge as
- 9:07
well as on the cloud. We want to be able
- 9:10
to train the VLA and the policies on
- 9:13
with using agent core. Um and we want
- 9:16
that to happen on the cloud but we also
- 9:18
want to be able to call it directly on
- 9:21
edge so that our robot can uh execute
- 9:26
functions and policies faster. So this
- 9:28
is sort of like a hybrid model where a
- 9:30
part of it happens on the cloud and
- 9:33
another part of it happens on the edge
- 9:35
and strands can decide when to call
- 9:38
which part of it. And so this helps with
- 9:41
massive amounts of training as well when
- 9:43
it's constantly collecting information
- 9:45
and it's train able to train on that
- 9:47
information and learn from itself but
- 9:49
also just execute at runtime really
- 9:52
really quickly. Now, like I said, the
- 9:55
agent decides what to do and the policy
- 9:59
decides how it should be done. But he's
- 10:01
pretty smart. He should be able to pick
- 10:03
himself back up if he's not fully fallen
- 10:05
down. And he should be able to continue
- 10:07
moving along.
- 10:10
So, I think he's okay. Now, where does
- 10:13
this leave us? And why is this so
- 10:16
special? We started off with very
- 10:20
traditional robots. Robots have existed
- 10:23
since forever, right? And they've always
- 10:26
just been programmed, pre-programmed to
- 10:28
do to autom be automated and do a
- 10:31
certain set of tasks autonomously.
- 10:34
But there is a future in this world
- 10:38
where this these robot policies, these
- 10:41
VLA models could be so advanced that we
- 10:45
wouldn't even need to do this. They
- 10:47
could be as large as our large language
- 10:50
models. So that ah wait hang on he's
- 10:53
falling back again.
- 10:55
I'm gonna see if I can get him to move
- 10:57
back up.
- 10:59
Good boy. Stop.
- 11:02
Then he's fallen off again. Um we get to
- 11:05
a point where these large language the
- 11:08
the VA models could be as large and as
- 11:11
amazing as our larger language models
- 11:13
and they know they have all the
- 11:15
information in the world and we wouldn't
- 11:17
even have to do this. we might just have
- 11:19
to feed in one simple model and then we
- 11:21
could give it to him and then he would
- 11:23
know exactly what to do. But until that
- 11:25
point where we don't have to fine-tune
- 11:27
on top of existing VAS and existing
- 11:30
policies, we can do this. And this is a
- 11:33
stepping stone towards a future where we
- 11:38
don't need to train robots anymore. So
- 11:40
now if we wanted to do more things than
- 11:43
just the tasks it's trained on, give it
- 11:45
an agent and see what it can do. And so
- 11:48
let me quickly go back to my demo and
- 11:51
I'm going to show you how it's actually
- 11:53
working.
- 11:59
Okay. So this is my so this is strand
- 12:03
here. This is scout here. And I've been
- 12:05
telling him to do a bunch of things. So
- 12:07
I can say, "Hey, do something
- 12:11
complex."
- 12:15
That's not complex. He's going to be
- 12:16
thinking now. Ah, he's going to fall
- 12:18
off.
- 12:21
So he's saying, "Let's spin. Full 360.
- 12:24
Done. Still safely on the stage. I can
- 12:26
see the bright stage lights and the
- 12:28
audience seating area." All good. What's
- 12:31
there? A challenge.
- 12:34
>> So he's speaking. I called this my
- 12:36
signature performance,
- 12:40
>> but he's not doing anything. What are
- 12:42
you doing?
- 12:45
He clearly seems to be speaking, but
- 12:47
what are you doing? Please do something.
- 12:50
He just turned off his headlines. Cool.
- 12:53
Okay, now he's calling. So, do you see
- 12:55
it saying calling rover speak, which was
- 12:57
the function that it called because I
- 12:59
said do something complex. So now it
- 13:01
spoke, but now I think it should have
- 13:03
been attempting to do something and it
- 13:05
fell off because it tried doing
- 13:06
something.
- 13:08
I've actually seen it do like a funky
- 13:10
dance, like this funky dance move. But
- 13:14
he's got a mind of his own right now.
- 13:16
What's going on under the hood here?
- 13:19
Couple of things. The first thing is
- 13:21
here, I can use this. What is the point
- 13:23
of creating him? I can use him to create
- 13:25
my data sets because I'm able to also
- 13:29
manually move him. I will get him to
- 13:31
navigate in the direction that I want
- 13:33
him to and then I can create training
- 13:36
episodes and I can get information on
- 13:38
how he's responding and how he's
- 13:40
reasoning based on the questions that I
- 13:42
ask. And this is super good information
- 13:44
for me to then be able to make him do a
- 13:47
better job of it. So that's one part of
- 13:50
this whole process and this experiment
- 13:52
of getting of giving him his own
- 13:54
autonomy and getting him to do things so
- 13:56
that I can create more data but also
- 14:00
apart from that uh this is my
- 14:03
configuration. So over here under the
- 14:05
hood strands agents which is your
- 14:08
harness SDK is using currently anthropic
- 14:12
claude opus 4.8 under the hood. So that
- 14:14
is the brain and then this is my simple
- 14:17
prompt where system prompt where I'm
- 14:19
telling it what it's supposed to be
- 14:21
doing and I'm telling it all of the
- 14:23
rules and I'm also giving it access to
- 14:25
all of the rules that it's already got.
- 14:27
So I'm telling it what each of these
- 14:29
rules are meant for. And so that's how
- 14:33
strand decides which tool to invoke
- 14:36
based on what I'm asking it to do. And
- 14:38
the voice that it's using is the one of
- 14:41
open AI real time. And I've also given
- 14:44
it more information for it to be able to
- 14:48
like just safety and guard rails to
- 14:50
ensure that it's doing really well. Now
- 14:52
it's this is these are two of the
- 14:54
agents. The other thing that it can do
- 14:56
is also chat with me on Telegram. This
- 15:00
is amazing because when I'm not at home
- 15:02
and I still want to get it to speak to
- 15:04
me, I can say, "Hey, scout.
- 15:07
Who is turn around uh spin around
- 15:12
analyze?" Uh-uh. Don't fall off. Analyze
- 15:16
the room and tell me who is the best
- 15:21
looking person. This is always a hit or
- 15:23
miss. Don't blame me if if Scout decides
- 15:26
to be biased. I tried playing with this
- 15:28
because it makes me feel like Snow White
- 15:31
um and the queen saying mirror mirror on
- 15:33
the wall who is the fairest of them all
- 15:35
and so let's see if Strand can give us
- 15:38
that. So it's saying haha on it on there
- 15:40
spinning around to scope the room. Is he
- 15:43
spinning? He is. Looks like he's making
- 15:45
and let's look at what he's looking at
- 15:47
now. He's still looking at the stage.
- 15:49
This is the other miller. He's looking
- 15:50
at me. Hi. Am I the prettiest? Oh, you
- 15:53
flatter me. But no, turn again. Spin
- 15:55
some more, please.
- 15:57
He's decided not to spin more. Let's see
- 16:00
what he says.
- 16:07
Spin complete. Here is my analysis of
- 16:09
the room. You can see my screen, right?
- 16:11
I have no way of zooming this in. Um,
- 16:14
spotted six to seven people total. A
- 16:16
couple seated front center near the
- 16:18
bright stage, right? A few more in the
- 16:20
audience. One person a dark outfit on
- 16:22
the stage. The rocking khaki jeans and
- 16:25
sneakers. Thank you very much. Oh, no,
- 16:27
no, no. The person in front of me, cocky
- 16:29
jeans and sneakers, clearly walking with
- 16:33
purpose on stage. Uh, best looking.
- 16:36
Honestly, from my low angle ground view,
- 16:38
it's tough to tell faces, but the person
- 16:41
on the stage right now gets style points
- 16:43
for the confidence stride and the
- 16:45
dramatic blue curtain backdrop. Thank
- 16:48
you very much. Every time I need a
- 16:49
confidence boost, I can be the only
- 16:51
person in the room and ask this guy
- 16:53
who's the prettiest of them all, and he
- 16:56
will always choose me as the answer.
- 17:01
[laughter]
- 17:02
Thank you very much.
- 17:18
>> [music]