AI Engineer World's Fair 2025
Ship it! Building Production-Ready Agents
Read the talk
From a Laptop Dice Agent to Managed Execution
A tabletop RPG assistant shows what must move beyond the laptop: model access, instructions, the agent loop, execution history, and the tools that act on its decisions.
From a talk by Mike Chambers
Before you start: Basic Python knowledge and familiarity with language-model tool calling will help; AWS Lambda and Bedrock concepts are introduced as they appear.
Start with a die, not a weather forecast
How do you take a working Python agent and get it running at cloud scale? Mike Chambers frames the problem through tabletop role-playing games: a small assistant that can roll dice on a player’s behalf. The useful starting point is deliberately modest—a single Python file, with no agent framework, whose tool generates a random number. The demonstrations are prerecorded to avoid Wi-Fi problems, with execution shown in real time between playback advances.
The local model is Llama 3.1 8B, running through Ollama on Chambers’s laptop. His implementation includes a system prompt describing the available tools and examples showing how to invoke them. Those examples give the small model additional help translating a request into tool use. One such request involves a D20: a twenty-sided die.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Turn gameplay language into an action
Chambers starts the Python program in a terminal and enters “roll for initiative and add a dexterity modifier of five.” The user does not specify a function name or spell out the number of sides. The model uses its understanding of the game terminology to interpret the request, selects the dice tool, and has the program execute it.
In the local demonstration, the D20 roll returns 10; adding the modifier of 5 produces an initiative total of 15. That small interaction exposes the division of labor: the model interprets the request, executable code supplies the random result, and the agent incorporates that result into its answer. The behavior works on the laptop. The next problem is moving the machinery that produced it into a hosted environment.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The loop needs history to keep working
Moving an agent means accounting for more than model inference. Chambers begins with the model, which supplies natural-language understanding, and the prompt, which establishes the agent’s purpose, capabilities, and personality. Both matter, but neither by itself executes a task.
The agentic loop connects interpretation to action. It processes the input, invokes a tool, examines the result, and decides whether another tool call is necessary. At the application level, this can be ordinary conditional and while logic moving strings between components. That control flow still needs somewhere to run when the application leaves the laptop.
History is working context for the current task, not just memory of yesterday’s conversation. After a tool executes, the next model step needs the original request and the relevant steps and results so far. In the initiative example, retaining the dice result lets the agent continue from the roll it already made. Without that context, the next step cannot reliably build on the previous one.
Finally, tools let the agent act outside the model. The dice function is a minimal example of that agency. Model, prompt, loop, history, and tools form Chambers’s minimum viable inventory—not an exhaustive taxonomy, but a concrete set of responsibilities to place in the cloud.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Assign those responsibilities to Bedrock and Lambda
Amazon Bedrock supplies access to models from providers including Amazon, Anthropic, Meta, Mistral, and AI21 Labs; Chambers also points to the Amazon Nova family. For the orchestration around those models, he chooses Amazon Bedrock Agents, a managed service configured with the agent’s behavior and tools. This is the historical service shown in the recording: current AWS documentation calls it Agents Classic and says it is closed to new customers, while existing customers can continue using it.
The configuration calls the agent’s behavioral text an instruction. It is not quite the complete prompt: the service combines it with a prompt template associated with the selected model. A default template is supplied, and developers can edit it. The service also takes responsibility for the loop and conversational history.
An action group is a collection of tools. An agent can have multiple groups, but this example needs only one, containing the dice roller. AWS Lambda provides the execution environment for that tool code. The resulting mapping is compact:
| Agent responsibility | Hosted component |
|---|---|
| Language understanding | Model accessed through Bedrock |
| Purpose and behavior | Instruction plus prompt template |
| Loop and execution history | Bedrock Agents orchestration |
| Tool definitions | Action group |
| Tool execution | Lambda function |
Lambda handles scaling of the function execution; the action group tells the agent which functionality it can invoke.
A Lambda-backed tool can reach other AWS services or external systems and perform operations such as sending email. Chambers jokes about launching a rocket, then acknowledges that some use cases do not fit Lambda. The practical boundary is the code and integrations the function can actually execute. The dice roller keeps that boundary easy to inspect.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Create the agent and choose its role
The console makes the configuration visible, but Chambers explicitly rejects manual console operations as the production provisioning approach. He names Terraform, Pulumi, CloudFormation, SDKs, and SAM as routes for expressing the setup in code. The walkthrough uses the console so the audience can follow the settings.
The initial setup is straightforward:
- Open Agents in the Bedrock console and choose Create agent.
- Give the agent a name and a description that will remain recognizable months later.
- Describe its purpose as helping with tabletop RPGs.
The resulting builder shows game_master_agent, its description, resource-role settings, and the test panel. At this point, the agent’s basic identity exists; its model and behavior still need configuration.
Chambers selects Anthropic Claude 3.5 Haiku, describing it as small, capable, and fast—and more than this simple task requires. He then supplies the games-master instruction: help the user play tabletop RPG games. This is the behavioral text that will be combined with the service’s prompt template.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Make the tool understandable to the model
After saving the agent, Chambers adds an action group with a name and description. Here, descriptions have an operational role: the model reads them to decide whether the group contains functionality relevant to the request. Natural-language descriptions become part of the programming interface.
He selects the Lambda quick start, which creates a function, configures the permissions, and connects it to the agent. Within that group, he defines the Roll Dice tool and describes it as rolling a die with a specified number of sides. The tool description explains when to use the function; its parameter definition explains how to call it.
The number-of-sides parameter receives a name, a natural-language description, the type integer, and a required flag. Together, those settings tell the model that a tool call must include an integer specifying the die’s sides. Chambers clicks Create, saves the configuration, and reopens the action group to follow the link to its generated Lambda function. The connection exists, but the generated function still needs the dice logic.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Put the dice logic inside the Lambda contract
Inside the Lambda console, Chambers edits the generated Python boilerplate directly. Amazon Q Developer is integrated into the editor and suggests code as he works. The function imports random, reads the incoming event to identify the requested function and its parameters, then dispatches to the dice operation. That operation extracts the number of sides and generates a random result.
The response must fit the surrounding integration, not merely return a Python integer. In the documented function-details Lambda contract, parameter values arrive as strings even when the tool schema declares an integer. A handler therefore converts and validates the value, then wraps the result in the Bedrock response envelope. Using roll_dice and sides as the configured identifiers, the implementation can take this form:
python
import random
def lambda_handler(event, context):
function = event["function"]
parameters = {
item["name"]: item["value"]
for item in event.get("parameters", [])
}
response_state = None
try:
if function != "roll_dice":
raise ValueError("Unknown function")
sides = int(parameters["sides"])
if sides < 1:
raise ValueError("sides must be a positive integer")
roll = random.randint(1, sides)
body = f"Rolled a D{sides}: {roll}"
except (KeyError, TypeError, ValueError) as error:
body = f"Invalid tool request: {error}"
response_state = "REPROMPT"
function_response = {
"responseBody": {"TEXT": {"body": body}}
}
if response_state is not None:
function_response["responseState"] = response_state
return {
"messageVersion": "1.0",
"response": {
"actionGroup": event["actionGroup"],
"function": function,
"functionResponse": function_response,
},
}
The tool returns the roll itself. The agent can then use that result to answer the larger gameplay request, including its modifier. In the recording, Chambers formats the generated number into the response body, accepts Q Developer’s suggested response code, and adjusts the indentation to fit the boilerplate.
Clicking Deploy saves the edited function into the Lambda environment. This deploys the executable tool; the next step is to return to the agent and prepare its configuration for testing.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Prepare the agent, then test the hosted flow
Back in Bedrock, Chambers prepares the agent and points out alias IDs as part of the software development lifecycle. The deployment lifecycle distinguishes preparing and testing the mutable DRAFT from publishing an immutable version through a deployment alias. The walkthrough shows preparation and testing; it does not establish that a production alias was created.
He submits a more elaborate initiative request in the right-hand test pane. The hosted demonstration returns an initiative total of 15. The individual roll and modifier for this second run are not specified. What has changed is where the work happens: managed orchestration now coordinates the model and the Lambda tool. Chambers describes that environment as fully hosted and ready for cloud scale; the demonstrated result is a functional test, with no load or latency measurements supplied.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Beyond the dice demonstration
Chambers closes by returning to DeepLearning.AI training, offering courses that, at the time of the talk, were free and included an AWS environment for experimenting with Bedrock Agents. The invitation extends the walkthrough into hands-on practice rather than adding another deployment step.
Two further technical topics remain outside the demonstration: hosting MCP servers at cloud scale and a new open-source SDK for developing model-first agents. Chambers does not name the SDK here or demonstrate either topic. He invites those conversations at the AWS stand, where the virtual dice example also has a physical counterpart: a D20 to take away.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Model variants and commands for running Llama 3.1 locally, including the 8B model used in the walkthrough.
CloudFormation resource syntax for configuring an agent and its action groups as infrastructure code.
Further reading
Input events, response envelopes, permissions and Python examples for implementing agent tools in Lambda.
How working drafts, immutable versions and aliases support deployment and rollback.
- Introducing Strands AgentsArticle
AWS's launch explanation of its open-source SDK, model-driven agent loop and Python tool definitions.
Updates since the talk
- Amazon Bedrock Agents documentation and availabilityDocumentation
Managed-agent concepts and current availability notice: Agents Classic is closed to new customers; existing customers can continue using it.
DeepLearning.AI's notice retiring Serverless Agentic Workflows with Amazon Bedrock.
Read the complete timestamped transcript
- 0:00
[upbeat music] Um, yeah. So my name's Mike Chambers.
- 0:16
I'm gonna pick you up a little bit there. So I'm from Queensland in the eastern part of Australia, but that's okay. Um, yeah, very happy to be here. So I'm a developer advocate for Amazon Web Services, um, and I completely and utterly and only and totally ge- uh, spec- uh, specialize in generative AI.
- 0:32
Used to be machine learning, now it's generative AI. Um, I'll be talking about why this slide is up here in a moment. Any tabletop RPG players in the room?
- 0:40
There's got to be at least one or two. There are some. Randall, you were saying you were before. Okay. It doesn't matter if you don't get that. But I will be showing some code, um, and what I'm gonna be showing is how to get the code and how to get into production.
- 0:52
So if you're a developer, this is how you can get your code and get it to cloud scale. If you're a leader, then this is how you can get your developers to get their code and get it into cloud scale.
- 1:01
Um, just a little bit about the kinds of things that I've done in the past. Um, so, um, I was incredibly fortunate a couple of years ago to work with Dr.
- 1:09
Dr. Andrew Ng, um, and some colleagues from, um, AWS on this course. This is the Fundamentals of LLMs. Um, over three hundred and seventy thousand people have taken this course so far.
- 1:20
It was the first of its course of its kind. I also got to play, um, Transformers with Andrew, which is cool, and if you get the reference there, I'm playing with Transformers.
- 1:29
Okay. And if you don't know who this is, um, that's Optimus Prime. Okay. [laughs] I think I'm holding, um, I can't... What's the other one called? Um, is it... Anybody?
- 1:40
Megatron. Megatron. Thank you. Yes. I ca- Yes, that's right. Um, so, um, let me jump into it. Let me jump straight into it. Um, some of you saw that code was coming, and code is coming.
- 1:50
Now, everything I'm gonna show is pre-recorded 'cause Wi-Fi, right? We know that. Um, but everything that I'm showing also is in real time. So what I wanna show first of all is just something super, super simple.
- 2:01
This is a single Python functio... a single Python file, um, which contains an agent, right? And it's the agent I'm going to use for the demonstration moving forward. This is where we get to dice rolling and T- TRPG, and the idea here is that I wanna do a simple agent with a simple tool that's not getting the
- 2:18
weather. 'Cause we know how to do that. Um, so in this code here, it doesn't use any frameworks or anything at all. It's actually kind of inefficient. Um, but I have this one, what we'd call a tool here.
- 2:30
This is my tool. Um, it's how to roll a dice. Essentially, it's a random number generator, um, but, uh, I'm calling it a dice roller. Um, and you can see here, um, if you, if you're, uh, familiar with this, it's using Ollama, um, and it's using the, um, uh, the Llama three point one eight billion parameter model.
- 2:48
Super tiny, just running on my laptop. This is literally an agent running on my machine. Um, so if we skip through here, I've got some things which I've sort of collapsed down for brevity.
- 3:00
This is a simple agent. It's an agentic flow. We're gonna talk more in detail about what agents are in a moment. I have my system prompt where I tell it, um, what tools it's got available.
- 3:10
Um, I then also actually do include some examples as well. The reason I include examples, again, it's a tiny little model, and it just needs a little bit of a helping hand to understand how to use these tools, um, for example, to roll a D20.
- 3:23
A D20, this is gonna come up again in this session, so I'll tell you now. It's a twenty-sided dice. Um, if you wanna get one, we have them on the AWS stand.
- 3:31
Come and see us afterwards. You can have an IRL D20. But we're going to have an agent which will roll it for us. Um, so, um, let's just open up the terminal.
- 3:40
I'm just going to run this locally so you can see the kinds of things that my agency's go- uh, agent is gonna do. Um, so I'm just running my Python code here, um, and you can see it's waiting for my prompt.
- 3:49
So I'm going to... or waiting for my input. I'm going to tell it, um, okay, this is some terminology here from gameplay. Um, roll for initiative and add a dexterity modifier of five.
- 3:59
That means something to the few people that put their hands up in the room. Um, but it basically means that what I've done is I've passed in my natural language into the agent.
- 4:09
It's used its large language model and its language understanding to figure out what I meant by that. It's then looked at the tools that it's got available. The tool it has available is to roll a dice, and then it's performed that action, and then we've got an outcome here.
- 4:23
So it's rolled a D20. Um, it's come back with a random number of ten. It's added five to it. I've got my output of fifteen. So this is a simple, really simple expli...
- 4:33
uh, example of what an agent... how an agent's structured and what an agent can do. I know it's just a random number generator, but I think it's pretty exciting.
- 4:43
So I wanna take this code though, which is all running on my machine at really low scale, and I want to make this, uh, cloud scale. I wanna get this production ready.
- 4:53
So that's what I'm going to look at next. So let's, um... Yes, let's get back into slides just for one moment, and I wanna talk about the anatomy of an agent.
- 5:02
We've just looked at it running there, but let's look at the anatomy of an agent. And as we're doing this, each one of these things, uh, we actually have to get into the cloud, running at cloud scale, so that this is the components that we need to scale.
- 5:15
And so the first thing, I think it's probably the obvious thing, is the model. This is actually super simple and super easy for us to do, um, as in they exist already, so we can just go ahead and use those.
- 5:25
But this is our natural language understanding. Of course, we need this to be able to run our agent. Um, the next thing that I've got on my list, and this is my list.
- 5:34
There's probably other things you could add to this, but I think this is a minimum list that you need for an agent. Uh, you need a prompt. So you need something to explain to the agent why it exists in the world and what kinds of things it can do.
- 5:45
Give it a personality, for example. Um, next, a loop. So this is the agentic loop. So this is the ability for the agent to be able to, um, think essentially.
- 5:56
So it, it looks at the input, and it can then process that input. It then needs to go and use a tool. But then it needs to evaluate whether that tool actually answered the question or not.
- 6:05
It needs to figure out if it needs to go and run another tool. It needs to loop around. It really is nothing much more than a, a while statement, if, while, whatever, with some strings flowing around.
- 6:15
A lot of this stuff is just string manipulation, but we need that to be-
- 6:19
Hosted and, and cloud scale. Next up, history. This is a really important one actually, and I've had a couple of deep conversations about this recently. Um, when I say history, and I t- talk about conversational history, people think of that as like, okay, well, I'm asking my agent to do something today, and tomorrow I want it to
- 6:36
remember what I asked it yesterday. It's actually a little bit more deeper than that. The actual conversational history inside of an agent is, is crucial to the running of the agent.
- 6:46
So when we ask it that question, uh, such as rolling, you know, rolling for initiative or whatever it might be, um, that goes in, and then it does some reasoning steps, right?
- 6:55
It decides what it wants to do, and then it goes and calls a tool, and the results, the stuff that we're talking about before in the loop. But it needs to remember those things that it's, that it's done so that, um, it- each next step, it can do that within the context, um, of what it's done before.
- 7:12
So history is... and conversational history at a low level is actually really important. Um, and then finally, I'm gonna have tools here. So these are, of course, uh, how our agent has agency to be able to go and perform something in the outside world.
- 7:27
So another important part. Are there other components of agents? Probably, yes. Yes, there absolutely are. But this, I think, is the base fundamentals. You need these things in order to be able to have a, the minimal viable product, I guess, of a, of an agent.
- 7:41
So I'm here from AWS. Let me tell you about what AWS can do to host these agents at cloud scale. The first one, I mentioned it before as being easy.
- 7:51
Obviously, anybody who works for a model or a bo- laboratory would say actually making agents-- uh, making models is actually kind of tricky. But they've done it for us, right?
- 7:59
So the models exist. We've got Anthropic, we've got Amazon Nova model, and this icon here represents Amazon Bedrock. So Bedrock is a suite of capabilities that allow us to be able to build, uh, generative components into the applications that we're building.
- 8:15
So we can just take these components, slot them in, and build something. We have models from a number of different leading providers. Amazon, like I said, Anthropic, Meta, Mistral, um, AI21 Labs.
- 8:27
We have a number of different models available. You can plug them into your system. So that's the kind of the easy bit. Um, let's now build up the actual agent itself.
- 8:36
And so for that, I have Amazon Bedrock Agents, and Amazon Bedrock Agency's fully managed. There's no infrastructure to manage with this. You can just put your configuration in, and it will be cloud scale.
- 8:47
So the answer to the question that I'm here to answer is actually really straightforward. We're just gonna go and use this service. Now, inside of that, we have, uh, the configuration that we're gonna have for our agent.
- 8:57
Now, um, I have put here instruction. Instruction is the terminology we use. This is, again, the personality of the agent. It's a bit like the prompt. It's not quite the prompt because it gets combined with a prompt template to be the actual prompt.
- 9:11
But this essentially, for all intents and purposes, is our prompt. That prompt template, by the way, if you're interested, you can absolutely go and edit that if you want.
- 9:19
But you get delivered a default prompt template with the model that you've selected. Um, then we need to ha-- well, all of those things I talked about with the, the loop and the history, conversational history, it's all taken care of, so that's all just inside of the service.
- 9:34
But then from our configuration standpoint, the next thing is the action group. So this is where we connect into tools. So an action group is a collection of tools.
- 9:43
That's what you can see that as. I've got a couple of different action groups here just to show that you can have more than one. We only need one because I only have one dice rolling tool.
- 9:53
Um, and you see in the middle here, we've got Lambda. So hopefully you're familiar with Lambda. It's a, a function as a service. It scales super well. It handles that scaling for you.
- 10:03
It's just the way the service works. And it's a perfect place to host these kinds of tools. And therefore, your tools can do anything that Lambda can do. Which is, I mean, I'd be interested if you can find a use case that Lambda can't do.
- 10:17
There are some. But anything, anything that your code can do in there, um, your tool can do, including reaching out to the outside world, reaching to other AWS services, sending an email, launching a rocket, whatever it is that you wanna do.
- 10:30
Actually, I'd really like to see launching a rocket. So I say that from time to time. We need to go do that. We need to build that. So I've whistle-stop toured through those components.
- 10:40
The important things to remember there are the action groups, really, 'cause that's maybe terminology you haven't come across before. Um, so now I'm going to dive into the console, and we're gonna build this.
- 10:51
Again, this is all real time. I'm advancing it forward with my clicker, right? But, but in between those things, it's all real time. There are some people in the room that are now saying, "Well, hang on a minute.
- 11:00
You were saying ship this to production. I'm not gonna ship to production with ClickOps. That's awful." And you're right, it is. And so all the things that I'm gonna show you are all possible as well with Terraform or Pulumi or CloudFormation or SDK or SAM or whatever infrastructure as code framework that you wanna use.
- 11:18
So bear that in mind. But I'm showing you in the console 'cause it's easier to look at. All right. So what I need to do is just, uh, I'm at the Amazon Bedrock part of the AWS console page.
- 11:30
I've gone down to Agents on the bottom of the left or down on the left-hand side, and this next little part's going to be very bouncy ball, kind of easy stuff.
- 11:40
I'm gonna click Create a agent. Okay. So then I get to name it, and I get to give it a description so that six months from now, when I go into my console, and I was like, "What was that agent for?"
- 11:49
I say, "Oh, that's what that agent's for." So it's always a good idea to use descriptions in anything you do inside of AWS. So, um, I'm saying it's an agent to help me play tabletop RPG.
- 12:00
If those are the questions you have, by the way, we can definitely go to the booth afterwards. We can talk a lot about this kind of stuff. Um, so I've got that set up.
- 12:08
Um, I scroll down. You remember one of the pieces of configuration that we needed was to connect it to our model. And so I get to choose models here.
- 12:16
I've got the Amazon Nova models. I'm gonna select the Anthropic, um, Haiku 3.5, 3.5 Haiku. Um, it's a small, it's a capable model. It's fast. It's probably more than we need for this very simplistic, um, agent, but it's a good one.
- 12:31
And so Here, I'm adding in those instructions. If you remember before, the instructions get combined with the template to become the actual prompt. So you're a games master who can help me play tabletop RPG games.
- 12:44
That's probably what you're gonna take away from this, right? Everybody's gonna go away and start playing, um, these games. Um, so I've defined what I want my agent to be.
- 12:51
So I click Save so that I've got it ready to go, and the next thing I have to do is action groups. So once we've done that... Yes, so we go and we scroll down to action groups, and this is where I'm going to connect in my logic with, um, the code execution that we were talking about
- 13:07
before. So let's click Add. Guess what? It wants a name and a description. We're familiar territory here. Um, and so we can give it this description. Now, these descriptions are read by the large language model so that it can figure out what this tool is for.
- 13:22
Um, and this is sort of this new paradigm of programming, right? So in terms of definitions and schemas for how these things work, we actually write in natural language in here so that LLM can read it and figure out if that's what they wanna do, or what...
- 13:35
That, that's what they wanna use. So we've got our action group as a whole. Now let's go and add in the actual code. We have a few different options here, and this option here is the recommended one, which is to use Lambda, which we saw in that diagram before.
- 13:49
Also, with this quick start here, it'll set up the Lambda function for you, it'll do all the commu- uh, the permissions for you, um, and it will hook it up to the agent for you.
- 13:58
So it's a really quick way to get started. Definitely recommend using that. Um, and now we come down to define the actual tool itself that we want. This is my dice roll or my roll dice.
- 14:09
I can... I, I flip between the two. This one's gonna be called Roll Dice. And again, we're giving it a description. This description's important because it tells the LLM what, uh, what this does and whether it wants to use it or not.
- 14:21
Um, and so it's got, you know, roll the dice with a certain number of sides. So we need a way to pass in those certain number of sides. This was all in the code before as well.
- 14:30
Um, and so if I scroll down here, I get the parameters, and I get to, again, just describe these parameters that I want. Just expanding this out because I'm zoomed in for the screen's sake, um, and I get to add in my parameter.
- 14:42
And guess what? I give it a name [laughs] and I give it a description, and again, the description is something which is read by the large language model. We're following the pattern here, right?
- 14:49
So it knows what this is for. Um, and I'm going to set this up as an integer value because I only have a, a, you know, an integer number of sides on any dice.
- 14:59
Um, and I'm gonna say it's required. I need this to be there. I need to tell the model that if you're using this tool, you must provide me with an integer for that.
- 15:08
Okay. I know I'm going fast, but I'm respectful of your time, and I wanna show you this working. So let's click Create. Again, this is real time. It's gonna go ahead and build that Lambda function for me, integrate the permissions for me, and have everything set up.
- 15:22
And so once I save this and scroll down, I can get back to my action group, dive into my action group again, and what I have inside of there is now a link to the Lambda function.
- 15:34
So code's coming back, and we just need to put this logic into our Lambda function so it can work for us. Now, I'm gonna do a little bit of quick and dirty here.
- 15:42
I'm gonna take the boilerplate that it provided for me, and I'm just gonna whack in some, um, function to allow us to do this dice roll. Um, so here's my Python inside my Lambda function.
- 15:52
So this is just inside the console. You'll notice that as I'm coding here, um, Amazon Q Developer is actually built into the console, into this code editor, and it'll be making suggestions for me in terms of what code I might wanna put in.
- 16:05
So I'm going to import random, which of course is necessary. If you're familiar with Lambda already, then you'll know that you get this event that comes in, and that event sort of triggers how this thing is gonna work.
- 16:16
Um, and we have here a function which is passed in, so it's telling us which function we wanna use, um, and it sends in some parameters as well. So let's, um, rattle through putting some code in.
- 16:26
I'm gonna say, okay, well, if the function that we're calling is roll dice, um, then I wanna basically go and grab the number of sides, generate my random number, and off I go.
- 16:37
So with it being real time, you have to wait for me to actually type, um, which is the way it is, and you also have to wait for me to paste this one because I'm less good at doing this one by hand.
- 16:47
Um, but in it comes, and we're nearly there.
- 16:52
So the next thing I need to do is just format my response. So my response body here is going to have my, um, my random number generated. In this particular case, Q Developer, um, inside of this IDE knows exactly what I wanna do by this point, 'cause it...
- 17:07
I know you, you wanna play RPG. Um, so it's written the code for me, so I can just tab select, tab complete on that. Um, and then with a little bit of tidy up just so that it works with the boilerplate that was there, just gonna indent that.
- 17:21
Um, then I can go ahead and click the Deploy button, um, and that's all I need to do. So now I can go and click the Deploy button. Excellent.
- 17:30
And that's all I need to do. So that Lambda function now is being saved into Lambda environment. That's all you need to do. Everything should be ready to go.
- 17:37
So if I go back to my agent, um, I'm going to... I have to prepare my agent. And I just wanna talk through this for just one moment. Um, this is a production-ready environment, right?
- 17:47
So we have the agent, and then we have alias IDs in here. We've got the whole, um, software development lifecycle thing going on, so you can have different aliases as you're, um, uh, publishing out your agents.
- 17:59
Um, but once we've prepared that, we should be able to test it over on the right-hand side. And so let's ask it the question. I'm gonna be a little bit more flowery language in this case because we want to, um, stretch the model a tiny bit.
- 18:13
We're not really stretching anything at all. Um, and as soon as we've got this and I figured out how to spell initiative, um, it will roll the dice for us.
- 18:22
And as you might expect, it's gonna work. But what's happening here is that this agent is now fully hosted in a fully managed environment. It's gonna work for us at cloud scale, and our answer comes back with a quick 15.
- 18:34
I just wanna go and wrap, wrap this up then. Um, if you're interested in learning more about this. So I mentioned before about the courses we have on deep learning AI.
- 18:44
These courses are totally free. You get a free AWS environment to be able to play around with Amazon Bedrock Agents completely risk-free. I'll put this QR code back up in a moment as well.
- 18:54
Um, thank you so much. Um, so please come and talk to me following my prompt template. If you wanna talk about anything more than just this at cloud scale, MCP servers at cloud scale, I definitely wanna talk to you.
- 19:07
If you wanna talk about our new open source SDK for developing model first agents, this is the stuff I hadn't got time to fit into this presentation. Um, if you want an in real life [laughs] D20, then come and join me on the AWS stand in the expo hall.
- 19:21
If you wanna talk about anything else, then thank you so much for your time, and I will let you get to lunch. [audience applauding] [upbeat music]