# Harness Engineering: Building the Production Cage for Powerful Domain Agents — Mike Chambers, AWS

Mike Chambers, AWS

[Talk page](https://ai.engineer/talks/gxVZ_1tuuq4-harness-engineering-building-production-cage) · [Video](https://www.youtube.com/watch?v=gxVZ_1tuuq4)

## Harness Engineering: Building the Production Cage for Powerful Domain Agents

Mike Chambers builds from a small Strands agent to persistent sessions, separately managed memory and a cloud runtime, then shows how a built-in harness can replace application code with configuration.

### Using an agent and building one create different responsibilities

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

A coding assistant on your machine and an agent serving an audience can use similar models while demanding very different engineering. Mike Chambers, a senior AI specialist developer advocate at AWS, approaches that difference through the infrastructure surrounding the model. His opening background moves from generative AI education in 2023 to an MCP Lambda handler in 2025 that simplifies serverless tool serving. The live examples will make the same progression: start with an agent that works locally, then change how its surrounding parts operate.

![Recording frame at 99 seconds](https://ai.engineer/api/talk-essay-media/9f8bcf54c93e15904cdee37b2dfc4b7dad15d04f8185009b0050ba7a6d1d9e46)

Recording frame at 99 seconds

The first distinction is between **agents we use** and **agents we build**. Claude Code, Cursor and Kiro belong to the first category, alongside productivity assistants. The second category consists of agents developers offer to other people. These roles can connect—you can build an agent somebody else uses—but the builder has to choose behavior and resource use for that audience. A user's enthusiasm for consuming tokens does not settle how a service should operate.

A harness begins with the ordinary image of straps and fastenings controlling an animal; substitute a model and the analogy works. The more useful engineering definition is subtraction: take an agent, remove its model, and everything remaining is the harness. This definition includes the machinery that gives the model context, connects it to actions and manages its operation. It does not require a particular framework.

### Assistant standards should preserve ownership of deployments

[4:45](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=285s)

For a coding assistant with access to local files, the harness determines how it uses memory, which skills it follows and which tools or MCP servers it can reach. Documentation servers are one concrete destination. Teams can distribute these choices across their developers' assistants, extending familiar coding standards into shared harness standards. The environment becomes part of how the team asks software to be written.

![Recording frame at 387 seconds](https://ai.engineer/api/talk-essay-media/b1b4982365475b59cc15d68eabff7455fa8264f90e941955270a1e4f3799cd7c)

Recording frame at 387 seconds

The Agent Toolkit for AWS is presented as an installable aid for assistants helping with AWS development and deployment. Its purpose connects to Chambers's objection to “slop ops”: letting an agent make ad hoc cloud changes reproduces the problem of clicking through a console, only through a different operator. Console exploration can help explain a system. Production provisioning needs a representation the developer continues to own.

Consider the request to create an S3 bucket or obtain an EC2 instance. A direct agent action leaves the resource creation in the agent's interaction with the cloud. Chambers's preferred sequence asks the assistant to produce **infrastructure as code**, then uses that code to create the resources. The desired cloud result remains the same; the deployment definition now exists as code under the developer's control. The assistant helps describe and construct the deployment rather than becoming the only place its decisions live.

### A production harness has parts that must scale separately

[6:44](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=404s)

An agent built for users still needs memory, skills and tools. MCP can connect it to many kinds of functionality, but those connections are only part of operating a service. The builder also has to place the loop, payments, identity, runtime and context management somewhere. Observability and evaluations appear last in Chambers's list, followed immediately by his correction: they should come first.

Putting every responsibility into one container makes the container the unit you replicate. Chambers rejects that as the architecture for the thousands of users he has in mind: each component needs its own scaling consideration. The next examples focus especially on memory. Adding persistence inside a local program improves its behavior; moving memory into a connected service changes how that capability can operate and scale. That separation is his working meaning of harness engineering.

### From tools on a laptop to a conversation that survives an invocation

[8:14](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=494s)

The first example in Kiro uses the **Strands Agents SDK**. An agent receives a system prompt and two tools: an installable calculator and a time function defined with a tool decorator. This is already a small harness. The tools supply capabilities around the model, and Strands manages the agent loop. Chambers skips executing the proposed time query; the example establishes the structure of a laptop agent, with deployment capabilities still to add. He also enjoys pointing out that he wrote this one himself: “I deserve a round of applause.”

![Recording frame at 571 seconds](https://ai.engineer/api/talk-essay-media/2326bacbfbff857d5bb1ca9d87b76c8fe4305415e1b5cf544c6a93ece2279c81)

Recording frame at 571 seconds

The second Strands example, generated with Kiro, adds two distinct ways to retain information:

- **Session restoration:** A session manager maintains state between invocations and rehydrates conversation history when the user returns. This carries the conversation forward instead of making each invocation start without its earlier context.
- **Explicit remembering:** A `remember` tool lets the agent choose to retain information about the user, with longer-lived memories stored in files. This is separate from restoring the conversation itself.

The observable change appears in a World Cup question. Chambers starts the local agent, enters a greeting, then asks who will win. The response recognizes that he wants Australia to win, a preference he attributes to their previous conversations. The causal sequence is useful: earlier interaction leaves retained context; the session manager restores history on a later invocation; that context influences the new answer. The walkthrough does not distinguish whether this particular preference also passed through the file-based `remember` mechanism.

Remembering a preference does not give the model knowledge of the winner. Chambers says the agent also acknowledges that it does not know. The result is personalization: a later answer can refer to what the user cares about while leaving the outcome uncertain. Persistence supplies context for the answer, rather than evidence for a prediction.

What crosses the gap between two conversations? The flow below follows the history-restoration path in the example. The important relationship is between retained conversation state and the later response: the later invocation can use earlier information because the harness restores it. Both the agent and its persistence mechanisms still run on Chambers's machine, so the next step changes where memory is managed.

Conversation history connects separate invocations
The session manager restores earlier conversation context before the returning user receives a personalized answer.
- Earlier conversations — Contain context about the user's preference for Australia.
- Retained session state — The session manager maintains state between invocations.
- Later invocation — Conversation history is rehydrated when the user returns.
- World Cup response — Recognizes the preference while acknowledging it does not know the winner.
- Earlier conversations → Retained session state (State persists between invocations)
- Retained session state → Later invocation (Rehydrate history)
- Later invocation → World Cup response (Earlier context influences the answer)

### Choose the interface, then provision memory beside the agent

[12:35](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=755s)

**Amazon Bedrock AgentCore** supplies the cloud infrastructure in the next example. Its CLI walks through an agent setup, initially skipping the option called harness. This route can accept existing code or create a hello-world agent for customization. Chambers chooses generated Python code from the offered Python and TypeScript options.

![Recording frame at 911 seconds](https://ai.engineer/api/talk-essay-media/0383556a311a50dc83bb488f325729582f07e3ae746f71ded344a079dc253f37)

Recording frame at 911 seconds

Several choices remain separate in this setup:

- **Caller interface:** HTTP is the selected entry point. MCP serving and AG-UI for interactive chat agents are presented as alternatives.
- **Agent implementation:** Strands is the example framework, but Chambers describes support for other frameworks or custom code.
- **Model access:** The runtime is presented as supporting models beyond Amazon's own offerings and those accessed through Bedrock. The demonstration keeps the offered default model.

Memory is the consequential infrastructure choice. Selecting short-term and long-term memory causes the setup to create cloud infrastructure to manage those capabilities separately from the running agent. Chambers describes the memory infrastructure as connected to the agent and running asynchronously from it. The agent can use memory without containing the memory service inside its own execution environment.

What changes when memory moves outside the agent? The topology below shows the selected HTTP entry point, the agent's runtime integration and the separate memory infrastructure. The separation makes independent operation visible: memory remains connected to the agent while becoming its own managed component. After beginning local configuration, Chambers switches to a prepared project he had already deployed, so this sequence is a setup walkthrough rather than a fresh deployment completing onstage.

Agent execution and memory become separate components
The selected deployment connects an HTTP-facing agent to memory infrastructure outside the running agent.
- HTTP interface — The caller interface selected in the CLI.
- Strands agent with AgentCore integration — Retains the prompt, tools and connections while using the managed runtime.
- Managed memory infrastructure — Short-term and long-term memory operate separately and asynchronously from the agent.
- HTTP interface → Strands agent with AgentCore integration (Connect to the agent)
- Strands agent with AgentCore integration → Managed memory infrastructure (Session and memory connections)

### Keep the agent recognizable while changing how it runs

[15:35](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=935s)

The prepared project is still a recognizable Strands agent, now linked to the AgentCore app. Chambers assigns scaling and multi-tenant isolation to the managed runtime: developers can write an agent for one user without writing all the machinery for multiple tenants themselves. That is a substantial shift in responsibility, although the walkthrough does not explain the isolation mechanism or measure behavior under load.

The application capabilities remain familiar: tools, an MCP connection, a session manager, memory connections and a system prompt. Runtime integration surrounds them. The design therefore separates what the agent does from infrastructure that operates it, while still requiring the application to connect to the selected services.

`agentcore dev` opens a browser interface connected to the locally running agent. Chambers interacts with that local instance and describes seeing code updates appear live. The same interface can switch to a deployed version. Local iteration and hosted interaction share a development interface, but they address different running instances.

`agentcore deploy` applies the earlier infrastructure-as-code principle to the harness itself. It deploys the agent, runtime, memory and other selected components. Inspection then reaches both execution and persistence: traces help reveal what happened during a run, and stored memories help reveal what information survived it. These are concrete ways to investigate behavior; the talk emphasizes evaluation as a priority without developing an evaluation method.

### The skipped harness option removes the agent code

[18:04](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1084s)

The ending returns to the CLI option Chambers deliberately skipped. His examples needed relatively little application behavior: a system prompt and tools. He suggests that perhaps **80%** of agentic use cases or agent development could be covered by a prompt connected to MCP tools. This is his proposed estimate, with no measured coverage rate or defined population of use cases, so its useful implication is a design question: how much custom orchestration does this particular agent actually need?

![Recording frame at 1180 seconds](https://ai.engineer/api/talk-essay-media/0643759957c9c84d961f8aa67b2fe16507943519dfe70bfbffc52efa1a44dc6e)

Recording frame at 1180 seconds

The built-in harness offers a concrete alternative. The configuration shown is a simple JSON file naming a model and a system prompt, deployable with `agentcore deploy` without writing agentic code. The harness supplies the surrounding implementation while the developer specifies the model and instructions. The shown fields illustrate the simplified entry point; they do not explain how tools are declared in that configuration.

There are therefore two useful adoption choices:

- **Use the built-in harness:** Supply configuration and let the provided implementation run the agent, when that implementation meets the use case.
- **Adopt a component:** Keep an existing production agent and integrate a selected capability. Chambers's closing example adds managed, serverless long-term memory to an agent that already works.

Selective adoption preserves the point of separating the parts in the first place. A useful memory service need not require replacing the entire agent architecture. Strands, which Chambers closes by describing as an open-source, model-first framework, assembles the agent in these examples; AgentCore capabilities provide composable infrastructure around its operation. The final choice is how much of that surrounding work to build yourself and how much to take as a managed component.

## Key takeaways

- A harness is everything left after removing the model from an agent. Serving users adds runtime, identity, scaling, context management, observability and evaluation to the assistant's memory, skills and tools.
- Session restoration carries conversation history across invocations; an explicit remembering tool retains selected information separately. The World Cup example shows remembered preference influencing a later answer.
- Infrastructure as code keeps deployment definitions under developer control, whether an assistant helps create cloud resources or the AgentCore CLI deploys the agent and its surrounding services.
- Separately managed memory changes the architecture: persistence becomes connected infrastructure outside agent execution, with its own scaling consideration.
- A built-in harness can reduce application work to configuration, while composable services let an existing agent adopt managed memory alone.

## Resources

- [Amazon Bedrock AgentCore: Complete Course](https://github.com/mikegc-aws/amazon-bedrock-agentcore-complete-course) — A hands-on continuation through runtime, tools, memory, identity, policy, observability and evaluations. Its progressive assistant examples develop the integration details beyond this short walkthrough.
- [Lambda MCP Server examples](https://github.com/mikegc-aws/Lambda-MCP-Server) — Sample code for the serverless MCP work introduced at the opening, including a Strands client and a time tool. The README distinguishes this example repository from the separately maintained handler package.

## Related talks

- [Ship it! Building Production-Ready Agents](https://ai.engineer/talks/HT4l0DeP69I-ship-it-building-production-ready-agents) — Chambers's earlier dice-rolling example develops the model, prompt, loop, history and tool responsibilities that this talk expands into a production harness.
- [Introducing Strands Agents, an Open Source AI Agents SDK](https://ai.engineer/talks/Q3NreEAdKMc-introducing-strands-agents-open-source-ai-agents) — A focused next recording on the SDK used throughout the local and runtime-integrated examples.

## Slides

### Mike Chambers

Mike Chambers introduces himself as a senior AI specialist developer advocate at AWS before discussing harness engineering.

[0:36](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=36s) [Introduction to Mike Chambers, an AWS senior AI specialist developer advocate.](https://assets.ai.engineer/sites/aiecode2025/sha256/0ce07a03ed790513f762849734007da1e002bf54f25b16ef0f14529e2485ab0f.webp)

Hello!

Mike Chambers

Snr AI Specialist DA // AWS

Socials: mikegchambers

2
AWS Builder Center

### Speaker background

Chambers traces his path from a 2023 generative AI course with 439,910 enrollments to his MCP Lambda handler, downloaded about 35,000 times a month, and behind-the-scenes work on the Agentic AI Foundation.

[0:51](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=51s) [A timeline of generative AI education, an MCP project, and the Agentic AI Foundation.](https://assets.ai.engineer/sites/aiecode2025/sha256/108282525637370d75e35982b5df3a5ba50d65747d48d530f9db0a132cda2376.webp)

Why am I’m here?

2023
DLAI: Generative AI with LLMs
439,910 enrollments

2025
Creator of: mcp-lambda-handler
35k / month

2026
Agentic AI Foundation
THE LINUX FOUNDATION
...

3
AWS Builder Center

### Agents we use and build

Chambers distinguishes agents we use, such as Claude Code and Cursor, from agents we build. The talk focuses on the latter—even though one person’s built agent can become another’s tool.

[2:01](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=121s) [Two robot icons represent agents that we use and agents that we build.](https://assets.ai.engineer/sites/aiecode2025/sha256/401eebfd91268a28b5ddf1ab8507eb67cc96b1c1ed26e2716835caff3226f5f6.webp)

Agents that we use
Agents that we build

4
AWS Builder Center

### Harness definition

Chambers starts with the dictionary definition of a harness, then suggests replacing “animal” with “model” to describe its role in controlling a model.

[3:49](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=229s) [A dictionary definition describes a harness as straps and fastenings used to control an animal.](https://assets.ai.engineer/sites/aiecode2025/sha256/0aa4872a8795e7cd1e87d4a2dfb67858e2338e901d6dced9868c8afa62669aa2.webp)

Harness

A harness is a set of straps and fastenings used to control an animal...
(Merriam-Webster)

5
AWS Builder Center

### Harness

Chambers adapts the dictionary analogy: replace the animal being controlled with a model.

[4:12](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=252s) [The underlined word Harness on a purple background.](https://assets.ai.engineer/sites/aiecode2025/sha256/d848a2750fec1cf6c0519e690da480b3515c6c313362deb184915f600b317591.webp)

Harness

6
AWS Builder Center

### Harness engineering for coding agent users

Birgitta Böckeler defines the harness broadly: everything in an AI agent except the model. The slide expresses that relationship as Agent = Model + Harness.

[4:19](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=259s) [A Martin Fowler article result defines an agent as a model plus a harness, with attribution to Birgitta Böckeler.](https://assets.ai.engineer/sites/aiecode2025/sha256/37aa939a04af572e4877e72bdec05475c809fdf14fa84bf5bae929ac4d84d1d2.webp)

Harness

Harness engineering for coding agent users

The term harness has emerged as a shorthand to mean everything in an AI agent except the model itself - Agent = Model + Harness. That is a very wide definition,

(Birgitta Böckeler 2026)

Interface text:
martinfowler.com
https://martinfowler.com › articles › harness-engineering
AWS Builder Center

### Harness for humans

Chambers shows an Amazon result for human safety harnesses, joking that these are the wrong kind of harness for the talk.

[4:36](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=276s) [An Amazon search result for human safety harnesses, with product images partly cut off at the bottom.](https://assets.ai.engineer/sites/aiecode2025/sha256/2d75147dcb10ac9d28c7fc91a4411db94c8267713dcf8e490b39c7536d719ab5.webp)

Harness

Amazon.com
https://www.amazon.com › harness-humans

Harness For Humans
Browse safety harnesses in various sizes and styles for workplace protection. Discover options with reinforced webbing and comfortable padding for all-day ...
4.5 ⭐ store rating (10K)

More products
25% OFF

### Agent minus model equals harness

Remove the model from an agent, and everything left is the harness.

[4:42](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=282s) [A green slide states: agent minus model equals harness.](https://assets.ai.engineer/sites/aiecode2025/sha256/8f5230414583e383500da8b2a4fbc3d42860c521906fc6806ba749819a904f9d.webp)

Harness

agent - model = harness

11
AWS Builder Center

### Agents that we use

Chambers introduces a coding assistant with access to his files as an example for thinking about an agent’s harness.

[5:00](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=300s) [A robot icon above the words Agents that we use.](https://assets.ai.engineer/sites/aiecode2025/sha256/a29b2ed5e5ca18efe77d1b456aeec8d6f52b9a6f935554a41966de2836f5b9ca.webp)

Agents that we use

12
AWS Builder Center

### Harness: memory, tools, and skills

A coding assistant’s harness configures memory, skills, tools, and MCP servers, including connections to documentation. Teams can standardize these settings across their assistants.

[5:05](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=305s) [Green slide headed Harness, with memory, tools/MCP, and skills.](https://assets.ai.engineer/sites/aiecode2025/sha256/f8019bb8f361110cd3d688376c2557b772b8a66b20cd18ee69db9cdce0eb8199.webp)

Harness

memory

tools/mcp

skills

13
AWS Builder Center

### Agent toolkit for AWS

Chambers shares a QR code for the free AWS agent toolkit. He wants agents to write infrastructure as code so teams retain ownership of cloud deployments.

[5:47](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=347s) [Harness slide with an agent toolkit for AWS heading, QR code, and the slogan no more slop_ops.](https://assets.ai.engineer/sites/aiecode2025/sha256/70c973562c242a7cf6e3450a833edfb6dbf134d181d2f4dfc805389e05fbc777.webp)

Harness

agent-toolkit-for-aws

memory
tools/mcp
skills

no more
slop_ops

13
AWS Builder Center

### Agents that we build

Chambers turns from the agent he uses to the agent he plans to build, asking how its harness should manage memory, skills, and tools.

[6:55](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=415s) [A robot illustration above the words Agents that we build.](https://assets.ai.engineer/sites/aiecode2025/sha256/1627fe84db1389763899ff82747d39257b51e01a3bee315b2de000bdc605218a.webp)

Agents that we build

14
AWS Builder Center

### Harness components

For thousands of users, Chambers says each harness component needs individual scaling. He highlights observability and evaluations as especially important.

[7:29](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=449s) [Green harness slide listing loop, observability, evaluations, scaling, payments, memory, identity, tools/MCP, security, skills, context management, and runtime.](https://assets.ai.engineer/sites/aiecode2025/sha256/480d207f00323d26919ad65024e98d5330b938c2a45318779b1baffcb73d30db.webp)

Harness

loop
observability
evaluations
scaling
payments
memory
security
identity
tools/mcp
skills
context mgmt
runtime

16
AWS Builder Center

### Code

Chambers moves into his IDE to work through several code samples.

[8:22](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=502s) [White slide with Code!! centered on the page.](https://assets.ai.engineer/sites/aiecode2025/sha256/5e0b8e0afb68f17a5687d3c6b1ea57b495767d55e28ffaa2e266162d0b671647.webp)

Code!!

17
AWS Builder Center

### Simple Strands agent

Chambers configures a Strands agent with a system prompt, a custom time tool and a calculator. The framework manages the agent loop; he shows a time question without running it.

[8:47](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=527s) [Editor showing a Strands agent with a custom time tool and calculator; the agent configuration is highlighted.](https://assets.ai.engineer/sites/aiecode2025/sha256/6d230788a5ab6c696fc73aaa8b4c43e273782fdd4a6ec3597120449da52dc2aa.webp)

from strands import Agent, tool
from strands_tools import calculator

@tool
def get_time() -> str:
    """Get the current time"""
    import time
    return time.asctime()

agent = Agent(
    system_prompt="You are a simple agent who can do a couple of things.",
    tools=[get_time, calculator]
)

agent("What is the time?")

Interface text:
Kiro  File  Edit  Selection  View  Go  Run  Terminal  Window  Help
aiwf26
EXPLORER
AIWF26
_demo
1_simple
.venv
.gitignore  U
.python-version  U
main.py  U
pyproject.toml  U
README.md  U
uv.lock  U
agent
agent-scale
agent-scale-fast
deck
APPLICATION BUILDER
main.py  U
1_simple > main.py > agent
Thu 2 Jul 12:14 pm

## Full transcript

[0:16](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=16s) Hello everybody. Hello AI engineers. Are

[0:19](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=19s) we all having a good time still?

[0:22](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=22s) >> I'm having a good time. I mean, look at

[0:24](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=24s) me. I'm up here. I'm loving this. Um, so

[0:26](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=26s) yeah, thanks so much for joining me. Um,

[0:28](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=28s) I want to come and talk to you all about

[0:30](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=30s) harness engineering and all that kind of

[0:32](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=32s) stuff. Um, let me tell you who I am in

[0:35](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=35s) case you've not met me before. Um, my

[0:37](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=37s) name is Mike Chambers and I'm a senior

[0:40](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=40s) AI specialist developer advocate. Um,

[0:42](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=42s) and I work at Amazon at AWS. Um, little

[0:47](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=47s) bit about like uh how I managed to get

[0:50](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=50s) to stand here which is a very exciting

[0:52](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=52s) time for me. Um so um quite a while ago

[0:56](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=56s) in terms of generative AI anyway back in

[0:58](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=58s) 2023 um I had the amazing awesome

[1:02](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=62s) privilege uh to work with Antia my

[1:05](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=65s) colleague at the time and now she works

[1:06](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=66s) for Amazon AGI you've probably seen her

[1:09](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=69s) on this stage before um and the amazing

[1:11](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=71s) Dr. Andrew Ing on on a course about

[1:14](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=74s) generative AI with LLMs um sort of can I

[1:18](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=78s) say that we're approaching half a

[1:19](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=79s) million enrollments with that? It looks

[1:21](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=81s) like that's the case. And on a

[1:22](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=82s) three-week course, that's pretty cool.

[1:23](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=83s) If you can't tell, in that image, um,

[1:26](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=86s) I'm playing Transformers with Android.

[1:28](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=88s) That seemed like a really funny thing to

[1:29](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=89s) do at the time. Um, in 2025, I created

[1:32](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=92s) an MCP Lambda handler. It's downloaded

[1:35](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=95s) still to this day about 35,000 times a

[1:37](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=97s) month. Um, to help people in some of the

[1:39](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=99s) simplest ways of getting serverless MCP

[1:42](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=102s) serving happening. Um, I'm going to talk

[1:44](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=104s) about other things in relation to that

[1:46](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=106s) this time. So, we've moved on from that.

[1:48](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=108s) Um and in 2026, so the AWS is actually

[1:51](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=111s) one of the founding members of the

[1:53](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=113s) Aentka Foundation, part of the Linux

[1:56](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=116s) Foundation. Um I'm doing a little bit of

[1:58](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=118s) work behind the scenes on that. Hope to

[1:59](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=119s) do a lot more of that as well. So little

[2:01](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=121s) bit about me. Um so as I've been um

[2:06](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=126s) preparing for this, oh by the way, I did

[2:08](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=128s) reread the abstract for this session and

[2:10](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=130s) realized I said I'd be doing some live

[2:12](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=132s) coding and so I will. So all combined

[2:16](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=136s) fingers crossed please that that all

[2:18](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=138s) works for us. Um but as I've been sort

[2:20](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=140s) of traveling around a little bit as I do

[2:22](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=142s) and I was at the AI engineers uh session

[2:25](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=145s) uh summit uh uh conference in Melbourne

[2:28](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=148s) um and took a lot of it in and also from

[2:30](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=150s) the beginning of this week as well. I

[2:32](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=152s) just wanted to to to summarize some of

[2:35](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=155s) the things that I'm seeing and I'm

[2:36](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=156s) thinking and I really want to get across

[2:38](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=158s) and and what really matters to me and

[2:40](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=160s) that's this. There are two different

[2:42](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=162s) types of agents. Um, so we talk about

[2:45](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=165s) agents all the time, but I see two

[2:48](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=168s) distinct types of agents. And as I say

[2:50](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=170s) this, it's going to become really

[2:52](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=172s) obvious, but they're the agents that we

[2:54](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=174s) use. And so, you know, this is claude

[2:57](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=177s) code and cursor and kirao and all of

[2:59](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=179s) those types of things. And also things

[3:01](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=181s) that don't just generate code, things

[3:02](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=182s) that we use for productivity and the

[3:04](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=184s) like as well. And so those agents we use

[3:07](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=187s) in a certain type of way. There's the

[3:09](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=189s) agents that we use. And then on the

[3:11](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=191s) other side of it, we've got the agents

[3:13](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=193s) that we build. And that's actually more

[3:15](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=195s) to do with me and and actually it's more

[3:17](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=197s) to do with this presentation as well.

[3:18](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=198s) It's agents that we build and how we

[3:21](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=201s) think about agents that we build. Um and

[3:23](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=203s) and so I do really think that these

[3:26](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=206s) don't two things are quite separate and

[3:28](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=208s) they chain together as well. I might

[3:29](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=209s) build an agent that you use and this

[3:32](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=212s) still holds true. So token maxing, all

[3:34](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=214s) that kind of stuff, go for it if that's

[3:36](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=216s) what you want to do with an agent that

[3:38](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=218s) you use. But with an agent that you

[3:39](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=219s) build, think about it carefully. Make

[3:42](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=222s) sure that you're putting it together in

[3:43](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=223s) a way that's going to work for the

[3:45](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=225s) audience who's going to use that. So, I

[3:47](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=227s) promised that we were talking about

[3:48](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=228s) harnesses and harness engineering. So,

[3:50](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=230s) let's define harness. I'm sure I'm not

[3:52](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=232s) the only person to have put something

[3:54](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=234s) like this up. I don't usually do this

[3:55](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=235s) kind of thing and apologize if it makes

[3:57](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=237s) your skin crawl. This is a dictionary

[3:59](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=239s) definition of harness. A harness is a

[4:02](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=242s) set of straps and fastenings used to

[4:04](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=244s) control an animal. But if we took animal

[4:06](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=246s) out of here and put model in there, then

[4:08](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=248s) actually it's pretty right, right, that

[4:10](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=250s) that's kind of what a harness is. Other

[4:12](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=252s) people have done a much better job than

[4:14](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=254s) just the basic dictionary definition of

[4:16](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=256s) what a harness is. So Lang Chain has got

[4:19](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=259s) a article out. You've probably seen

[4:20](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=260s) stuff like that. Martinfowler.com

[4:22](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=262s) although Martin didn't write it. It was

[4:24](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=264s) Pitta wrote this. Harness engineering

[4:26](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=266s) for coding agents. Agents that we use,

[4:29](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=269s) right? So there are other ways of

[4:30](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=270s) looking at harnesses. What about Amazon

[4:33](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=273s) then? How do we see um harnesses? Well,

[4:36](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=276s) um no, okay, this is the wrong kind of

[4:38](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=278s) harness. Sorry, we do have strong

[4:40](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=280s) opinions on harnesses. I'm going to show

[4:41](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=281s) you all of that, but we sell all kinds

[4:43](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=283s) of things. So, in a nutshell, and if you

[4:46](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=286s) read those articles, um and if you've

[4:49](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=289s) had the conversations around here at

[4:51](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=291s) this event, of course, um a harness, you

[4:54](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=294s) take an agent, remove the model part

[4:56](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=296s) from it, and everything that you have

[4:57](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=297s) left, that's the harness. Okay, so let's

[5:02](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=302s) think about that in context of an agent

[5:04](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=304s) that we use. And so it's pretty, I

[5:08](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=308s) think, fairly straightforward. I have

[5:09](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=309s) this coding assistant. It's probably on

[5:11](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=311s) my machine. It has access to my files.

[5:13](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=313s) And I create a harness or the place I

[5:16](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=316s) work at has created a harness for me

[5:18](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=318s) which contains um how it's going to use

[5:21](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=321s) memory, the skills that I want it to

[5:23](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=323s) use, tools and MCP servers to allow it

[5:25](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=325s) to go to be able to go and connect to

[5:27](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=327s) documentation servers and the like. and

[5:30](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=330s) and well set up engineering teams have

[5:33](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=333s) got their standards that they've had.

[5:35](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=335s) They've had coding standards for

[5:36](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=336s) decades, but now they have basically

[5:38](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=338s) harness standards, the things that they

[5:40](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=340s) want to deploy to everybody's coding

[5:42](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=342s) assistance. So, in a nutshell, that's

[5:45](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=345s) what it is. I'm not going to talk to too

[5:47](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=347s) much more about that. Um, but I do want

[5:49](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=349s) to share one QR code with you, and I'll

[5:50](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=350s) try and give you a little bit of warning

[5:52](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=352s) before I bring QR codes out. This is the

[5:54](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=354s) agent toolkit for AWS. This is u

[5:57](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=357s) available on GitHub. Of course, it's

[5:59](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=359s) free. You can install it and it helps

[6:01](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=361s) you if this is what you're doing and

[6:03](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=363s) you're deploying code. If you're

[6:04](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=364s) deploying on AWS or you're thinking

[6:07](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=367s) about deploying on AWS or or maybe you

[6:09](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=369s) will one day, grab this toolkit, enable

[6:12](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=372s) your um uh agent to to help you in the

[6:14](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=374s) right direction. It's instructions for

[6:16](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=376s) how to install it on pretty much

[6:17](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=377s) everything. And the reason why I get

[6:20](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=380s) passionate about this is because I don't

[6:22](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=382s) want to see any more slop ops. Um, so we

[6:25](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=385s) always used to push back against click

[6:27](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=387s) ops in, you know, in the professional

[6:29](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=389s) cloud development space. Clicking around

[6:31](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=391s) on the console is great for being able

[6:32](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=392s) to figure out what's going on, but it's

[6:34](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=394s) not how you deploy things into

[6:36](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=396s) production. We can ask an agent what's

[6:38](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=398s) going on, but we don't want to ask the

[6:40](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=400s) agent to spin up an S3 bucket, get me an

[6:43](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=403s) EC2 instance, whatever it might be. We

[6:45](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=405s) want the agent to build up our

[6:48](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=408s) infrastructure as code which is going to

[6:50](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=410s) go and do that so that we still own our

[6:53](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=413s) deployments in the cloud. So no more

[6:54](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=414s) swap ops. Okay. So that's the agent that

[6:57](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=417s) we use. Now let's go and talk about the

[6:59](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=419s) agent that we're going to build. And I'm

[7:01](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=421s) going to get into the code as quickly as

[7:02](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=422s) I can and we'll do as much as it has

[7:05](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=425s) time for. So how do we think about a

[7:08](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=428s) harness in relation to the agent that

[7:09](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=429s) we're building? Exactly the same to a

[7:12](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=432s) point. Yes. We still want to have how

[7:14](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=434s) are we going to manage the memory? How

[7:16](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=436s) are we going to manage the skills and

[7:18](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=438s) tools in MCP by the way that that belies

[7:21](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=441s) a lot of stuff, right? Because you can

[7:22](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=442s) pretty much extend an agent to do almost

[7:24](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=444s) anything you want with a whole bunch of

[7:26](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=446s) different types of tools which could be

[7:28](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=448s) via MCP.

[7:30](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=450s) But with an agent that I am building, I

[7:33](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=453s) need to think about a lot more than just

[7:35](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=455s) that. especially if um like at Amazon

[7:38](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=458s) and like at cloud scale I'm deploying my

[7:41](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=461s) agent out to the masses. So how do I

[7:44](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=464s) actually manage the loop? How do I

[7:47](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=467s) manage um scaling payments, memory,

[7:49](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=469s) identity, skills, runtime, context

[7:51](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=471s) management, the rest of it and I have

[7:53](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=473s) left it to the last thing but it should

[7:54](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=474s) be the first thing that I say.

[7:56](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=476s) Observability and evaluations super

[7:59](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=479s) super important. How do we actually deal

[8:01](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=481s) with this? Do I write all of this code

[8:04](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=484s) down into one container and just deploy

[8:06](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=486s) it and scale that? Not really. If I want

[8:08](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=488s) to be scaling to thousands of users, I

[8:10](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=490s) need to think about each individual of

[8:12](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=492s) these components and how I'm going to

[8:14](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=494s) scale them out individually. And that to

[8:16](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=496s) me is harness engineering. This is the

[8:19](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=499s) serious side of stuff. This is the big

[8:21](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=501s) stuff that we want to get harnesses

[8:23](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=503s) working at real scale. Okay, let's see

[8:26](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=506s) if this works. I can feel your combined

[8:29](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=509s) goodwill being sent my way that we're

[8:31](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=511s) going to try and make some code work.

[8:33](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=513s) So, I'm here in Kira. This is my IDE of

[8:35](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=515s) choice here. And I've got a few

[8:37](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=517s) different samples that we're just going

[8:38](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=518s) to race through watching that clock

[8:40](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=520s) countdown fast. So, um just just make

[8:44](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=524s) sure that we're all on the same page

[8:45](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=525s) here and hopefully you can all see this.

[8:48](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=528s) Um of the code which I'm about to show

[8:50](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=530s) you, by the way, one piece of code, not

[8:52](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=532s) this one, has been generated by Curo.

[8:55](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=535s) Everything else is either a tool or this

[8:57](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=537s) one I actually wrote it myself. I didn't

[9:00](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=540s) use an agent for this. I know I deserve

[9:02](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=542s) a round of applause, but it's okay.

[9:04](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=544s) [laughter]

[9:05](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=545s) So, this is uh this is a Strand agent.

[9:09](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=549s) So, I've just taken the Strands agents

[9:10](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=550s) SDK. Um, and hopefully this kind of

[9:12](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=552s) thing is kind of familiar. I've brought

[9:14](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=554s) in an agent. I brought in the tool

[9:16](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=556s) decorator and I'm creating myself an

[9:18](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=558s) agent. The tool definition is down here.

[9:20](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=560s) Um, and so I just pass in my system

[9:23](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=563s) prompt. Things are pretty simple at this

[9:25](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=565s) stage and I've passed in a couple of

[9:26](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=566s) tools. Calculator is something that's a

[9:28](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=568s) library I can install and get time is

[9:31](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=571s) the one that we always use because I

[9:33](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=573s) don't tend to use agents to book flights

[9:35](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=575s) certainly not ones like this. Um and so

[9:37](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=577s) I can say something simple here like

[9:39](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=579s) what is the time? I'm not going to run

[9:40](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=580s) this because you know the time but you

[9:42](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=582s) can see generally how this works. Is

[9:44](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=584s) this a harness? Sort of. There's not an

[9:48](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=588s) awful lot to it, right? We've got the

[9:49](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=589s) tools in there. Our loop is being

[9:51](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=591s) managed for us by the framework. This is

[9:53](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=593s) pretty cool. So that's good. But

[9:55](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=595s) obviously if I was to run this, this is

[9:57](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=597s) running on my laptop. It's not running

[9:59](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=599s) at any particular scale. And we're

[10:01](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=601s) missing some of the attributes that I

[10:03](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=603s) want from the agents that I'm going to

[10:04](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=604s) deploy. Let me move on to my next agent

[10:07](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=607s) quickly. So this is also a strand agent,

[10:10](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=610s) but this one I actually asked Kira to

[10:12](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=612s) write it for me for this session um

[10:14](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=614s) because I wanted to include some more

[10:16](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=616s) stuff. And so inside of this agent, the

[10:20](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=620s) one main thing that I want to point out

[10:21](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=621s) is that I am uh included a session

[10:24](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=624s) manager. So my session manager is

[10:27](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=627s) helping me to maintain session state

[10:29](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=629s) between invocations. So this is a sort

[10:32](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=632s) of memory. It's a kind of medium-term

[10:34](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=634s) short-term memory kind of thing. It's

[10:35](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=635s) not proper long-term memory, but it is

[10:37](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=637s) there. And actually, it does store

[10:40](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=640s) long-term memories in files which are

[10:42](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=642s) down the side here that it's uh included

[10:44](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=644s) for us. So, if I just scroll down here,

[10:47](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=647s) you can see uh yeah, here's the agent

[10:49](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=649s) definition itself. Um, and we've got a

[10:52](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=652s) bit more of a system prompt because Kira

[10:53](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=653s) couldn't help itself. Um, and we've got

[10:55](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=655s) some tools here defined. Um, including a

[10:58](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=658s) remember tool that the agent can decide

[11:00](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=660s) to use to remember stuff about me. Um,

[11:02](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=662s) and then I've got my uh session manager

[11:05](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=665s) down there. And that session manager is

[11:06](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=666s) going to rehydrate the conversation

[11:08](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=668s) history when I come back to chat to it

[11:11](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=671s) the next time. and maybe the next time

[11:14](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=674s) is now. So, let's see if we can get this

[11:16](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=676s) working. Now, again, this is running on

[11:17](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=677s) my local machine. Um, and this is a demo

[11:20](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=680s) here. So, let's just type in hello

[11:22](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=682s) because I'm scared of typing too much

[11:24](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=684s) and spelling it wrong. Um, and it says,

[11:26](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=686s) uh, yeah, keep testing me. Bring it on.

[11:28](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=688s) Excellent. Um, um, who will win the

[11:33](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=693s) World Cup? So, obviously I need to know

[11:37](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=697s) this. And, um, what does it say? Yeah.

[11:40](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=700s) So, while you could just say Australia,

[11:42](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=702s) it knows I want Australia to win. It's

[11:44](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=704s) where I'm currently living. I'm

[11:45](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=705s) Australia. So, obviously Australia is

[11:48](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=708s) going to win the World Cup, but why has

[11:50](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=710s) it got that? It's because of previous

[11:52](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=712s) conversations that we've had. And

[11:54](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=714s) obviously, it's being honest that it has

[11:56](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=716s) no clue because that's coming from the

[11:58](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=718s) large language model, of course. So,

[12:01](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=721s) okay, looks at a couple of different

[12:02](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=722s) agents there, blasted through this. This

[12:05](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=725s) is um running on my machine. So this

[12:07](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=727s) isn't really getting me to clouds scale

[12:09](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=729s) of course and I'm I'm picking up and I'm

[12:12](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=732s) including various pieces in this like

[12:14](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=734s) memory. So let's go next. How do we get

[12:17](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=737s) to the point where I can deploy

[12:19](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=739s) something like this if not this actual

[12:21](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=741s) agent out at cloudscale and take things

[12:24](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=744s) like memory and deploy that separately

[12:27](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=747s) so it can scale separately. taking our

[12:29](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=749s) loop out so it can scale separately and

[12:32](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=752s) we can then bolt in all kinds of other

[12:34](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=754s) things as well. So in order to do that

[12:37](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=757s) I'm going to use something called um

[12:39](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=759s) agent core um and so we have bedrock

[12:41](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=761s) agent core. It's part of the stack that

[12:43](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=763s) we have at AWS and that's how I'm doing

[12:45](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=765s) this and how I'm deploying. So I've done

[12:48](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=768s) that already but I want to show you how

[12:50](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=770s) to start out with that and how we do

[12:52](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=772s) this. So if I go to here uh yeah I'm

[12:56](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=776s) ready to go. So, I have a command line

[12:58](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=778s) tool on my machine, the agent core

[13:00](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=780s) command line. Um, and so there's a QR

[13:02](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=782s) code at the end, as you might imagine,

[13:04](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=784s) so that you can get hold of this. Um,

[13:06](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=786s) but I can use this to help me deploy my

[13:08](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=788s) agent. Now, this steps me through like

[13:11](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=791s) many of these types of tools do. Um, and

[13:13](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=793s) it sort of steps me through what do you

[13:14](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=794s) want to do? So, this is my woohoo agent.

[13:17](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=797s) Um, and it's going to ask me a bunch of

[13:19](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=799s) stuff. And I wanted to show you some of

[13:20](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=800s) this as we step through. Now, strangely,

[13:23](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=803s) I'm not going to select harness. And

[13:25](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=805s) we'll come back to why I'm not selecting

[13:26](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=806s) harness in a second, but I'm saying I

[13:28](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=808s) wanted to deploy an agent. And what's

[13:30](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=810s) going to happen here is this command

[13:31](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=811s) line tool is actually going to step me

[13:34](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=814s) through and actually write an entire

[13:36](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=816s) agent. It's basically a hello world

[13:38](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=818s) agent that I can then go and customize

[13:40](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=820s) myself. Um, and so using this command

[13:42](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=822s) line is an easy way to get started with

[13:44](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=824s) agent core. So I'm going to keep the

[13:46](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=826s) default name. In fact, I'm probably

[13:48](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=828s) going to keep all the defaults here just

[13:49](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=829s) so we can see what's the option. Of

[13:51](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=831s) course, I can bring code if I want, but

[13:53](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=833s) I'm going to ask it to create some code

[13:55](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=835s) for me. So, it says, well, what do you

[13:57](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=837s) want? Python or TypeScript? And back in

[13:59](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=839s) the day, I used to do things like

[14:01](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=841s) activate functions and back propagation

[14:03](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=843s) in the machine learning space. So,

[14:04](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=844s) Python it is for me. So, I will choose

[14:07](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=847s) that. Um, and there's some deployment

[14:09](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=849s) options. There's also this I just want

[14:11](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=851s) to point this out like how can we

[14:13](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=853s) actually go and connect into our agent.

[14:15](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=855s) So, our agent that's running at scale in

[14:17](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=857s) the cloud, HTTP is probably the obvious

[14:19](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=859s) one, but we might want to have it being

[14:21](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=861s) served behind MCP. We might want to use

[14:23](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=863s) awesome little things like AGUI so we

[14:26](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=866s) can make nice interactive chat agents,

[14:29](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=869s) but I'm going to say HTTP. We can use

[14:31](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=871s) any um framework we want. I happen to

[14:34](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=874s) use Strand's agents SDK, but anything

[14:37](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=877s) you could write your own framework if

[14:38](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=878s) you want to um or your own own base

[14:41](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=881s) code. Any model is supported by this as

[14:44](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=884s) well. So, we don't just have to use the

[14:46](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=886s) Amazon models. Um, and we don't have to

[14:48](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=888s) use the ones from Amazon Bedrock, but we

[14:50](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=890s) can use any model. I'm using the one

[14:51](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=891s) here. I'm using Sonic 4.5 just because

[14:53](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=893s) that's offered to me at default. And

[14:56](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=896s) here's memory. So, this is the one thing

[14:58](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=898s) I wanted to show you. So, I can come in

[14:59](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=899s) here and ask for long-term and

[15:01](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=901s) short-term memory to be deployed. And

[15:03](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=903s) we'll see what this means in just a

[15:04](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=904s) second, but it's basically going to

[15:06](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=906s) create for us cloud infrastructure which

[15:08](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=908s) is going to manage those memories for us

[15:10](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=910s) separately from our running agent

[15:13](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=913s) running asynchronously from our agent

[15:14](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=914s) and connected of course. So there's

[15:17](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=917s) obviously other kinds of things we can

[15:18](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=918s) do. We can hit enter and it will start

[15:20](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=920s) to create the configuration of this

[15:21](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=921s) agent on my machine. Now I'm going to

[15:24](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=924s) skip over here and come back to the

[15:27](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=927s) actual code I have because I've already

[15:29](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=929s) done this of course. Um, and this is the

[15:31](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=931s) agent that it would be currently

[15:33](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=933s) deploying. Something like this. So,

[15:35](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=935s) we've built up here. This is a little

[15:36](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=936s) bit more complex. So, this is a strands

[15:39](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=939s) agent. You'll notice that it's got a few

[15:41](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=941s) more things added in. So, it's got the

[15:43](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=943s) linkage into Amazon Bedrock agent core

[15:45](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=945s) app, but pretty much apart from that,

[15:48](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=948s) that's all you need in order to be able

[15:50](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=950s) to scale this agent out at runtime and

[15:53](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=953s) do multi-tenant isolation. So you can

[15:56](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=956s) write an agent that works for one user

[15:58](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=958s) and then scale that out without you

[16:01](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=961s) having to write all the multi-tenented

[16:03](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=963s) code. It's a massive saver and from a

[16:05](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=965s) security and identity perspective, it's

[16:08](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=968s) makes it so much simpler. It's um it's

[16:10](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=970s) very very useful. So if I scroll down

[16:12](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=972s) through here, you can see the rest of it

[16:14](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=974s) is looking pretty similar. We've got

[16:16](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=976s) some test tools in here. We've got a

[16:18](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=978s) connection to MCP, so we can see how

[16:20](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=980s) that is done. Um, and we've got the uh

[16:23](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=983s) connection into our session manager and

[16:25](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=985s) our memory which is all built in here.

[16:28](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=988s) So, if I scroll down a bit more, we'll

[16:30](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=990s) be able to see somewhere where we

[16:32](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=992s) actually invoke the thing um which is

[16:34](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=994s) there. Um, and the system prompt is is

[16:36](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=996s) somewhere at the top. So, we can we can

[16:38](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=998s) scroll through this code. I'm going

[16:40](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1000s) through it quickly. You can write your

[16:41](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1001s) own code and do this with it as well. If

[16:43](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1003s) I go back over to my um uh code here for

[16:46](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1006s) just one second. I'm in the folder now

[16:49](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1009s) that has been created with that code

[16:51](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1011s) locally, it is actually deployed, but

[16:53](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1013s) let's assume it's not deployed quite

[16:55](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1015s) yet. I can come back in and type in

[16:57](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1017s) agentcore dev. And what that's going to

[16:59](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1019s) do for me um Wi-Fi permitting is it will

[17:02](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1022s) spin up for us a web uh browser. And

[17:05](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1025s) inside of that web browser, we're now

[17:07](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1027s) connected to that agent running locally.

[17:09](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1029s) So if I make updates to that code, we

[17:11](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1031s) would see that happen in real time here.

[17:14](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1034s) So I can say hello, I am doing the press

[17:19](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1039s) now. Um it knows that I'm coming to do a

[17:22](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1042s) presentation, but I think it does

[17:23](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1043s) anyway. Um and so yeah, you can interact

[17:25](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1045s) with the agent here. You can make

[17:26](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1046s) adjustments to the um to the code and

[17:29](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1049s) you'll see it update live here. Um but

[17:31](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1051s) you can also use this to switch over to

[17:33](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1053s) the live um deployed version. So with

[17:37](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1057s) agent core deploy it will use

[17:39](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1059s) infrastructure as co code like I talked

[17:42](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1062s) about before to deploy your agent out at

[17:45](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1065s) scale with the memory with the agent

[17:47](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1067s) with runtime and with many other

[17:48](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1068s) components if you choose to do so you

[17:50](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1070s) can use this interface then to go and

[17:52](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1072s) look at traces look at memory stored

[17:54](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1074s) look at all that stuff so that you can

[17:55](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1075s) debug and see what's going on. Now, when

[17:58](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1078s) we stepped through the um the the the

[18:02](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1082s) console just a second ago through the

[18:03](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1083s) the CLI app a second ago, we didn't

[18:05](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1085s) choose harness. I skipped out on that

[18:07](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1087s) one and I'm just going to show you that

[18:09](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1089s) quickly now. So, one thing we can do

[18:12](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1092s) instead is I think we can get to the

[18:14](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1094s) point you've seen I've deployed agents.

[18:16](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1096s) I didn't do very much. I just did a

[18:17](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1097s) system prompt and some tools and go. And

[18:20](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1100s) there's an argument to be made that

[18:21](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1101s) essentially if that's possible then

[18:23](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1103s) maybe 80% of um agentic use cases 80% of

[18:27](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1107s) agent development is kind of solved

[18:28](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1108s) already. We don't need to do much more

[18:30](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1110s) than system prompt connect to some MCP

[18:32](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1112s) tools and we've got what we want. And if

[18:35](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1115s) that's the case then we have harness

[18:37](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1117s) built into agent core. This is the

[18:40](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1120s) configuration for an agent. I just have

[18:42](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1122s) a simple JSON which is showing me which

[18:44](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1124s) model do I want to use and what system

[18:47](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1127s) prompt do I want to use. Can't get much

[18:49](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1129s) more simpler than that system prompt.

[18:51](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1131s) Um, and then this can also be deployed

[18:53](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1133s) with agent core deploy. So at this point

[18:55](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1135s) we don't have even any agentic code

[18:58](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1138s) either. We can just deploy it straight

[19:00](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1140s) out. If you want to know any more about

[19:02](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1142s) any of this then please do come and see

[19:03](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1143s) us down on the booth or see me after

[19:05](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1145s) this session. I'll be more than happy to

[19:07](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1147s) talk to you at length about this. 18

[19:09](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1149s) minutes is such a short amount of time

[19:11](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1151s) for me to be able to talk about almost

[19:13](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1153s) anything. But this is essentially all of

[19:17](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1157s) these components on here. There's a

[19:18](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1158s) mapping somewhere into something that

[19:20](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1160s) Agent Core has. I apologize for the

[19:23](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1163s) colors. It seemed like a good idea at

[19:24](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1164s) the time. Um, but this is an overview of

[19:28](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1168s) the different capabilities that are

[19:30](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1170s) composable out of agent core. So, you

[19:32](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1172s) can take any of these and use any of

[19:35](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1175s) them together or separately. If you have

[19:38](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1178s) an agent that's running in production

[19:40](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1180s) very happily at the moment, but you like

[19:42](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1182s) the idea of having long-term memory

[19:45](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1185s) managed for you serverless, then you can

[19:47](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1187s) just take that part and integrate it.

[19:49](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1189s) That's totally something you can do.

[19:50](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1190s) Here's a QR code. Sorry, probably should

[19:51](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1191s) have put that there a second ago. I'm

[19:53](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1193s) moving this QR code in just a moment,

[19:55](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1195s) but Amazon Bedrock agent core is that if

[19:58](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1198s) you're interested in the Strands agents,

[20:00](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1200s) which I happen to be using for this,

[20:02](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1202s) it's obviously it's it's free because

[20:04](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1204s) it's open source. Um, and it's a um a

[20:07](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1207s) model first framework for putting

[20:09](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1209s) together agents. It's super fast, it's

[20:11](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1211s) super powerful, and it's what I use all

[20:13](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1213s) the time. Thank you so much for being

[20:16](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1216s) with me in this presentation. Please

[20:18](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1218s) feel free to connect with me on

[20:19](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1219s) LinkedIn. I'd love to carry on the

[20:21](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1221s) conversation with you. have a fantastic

[20:24](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1224s) rest of show and have a safe travel as

[20:26](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1226s) you go home after the event. Thank you

[20:28](https://www.youtube.com/watch?v=gxVZ_1tuuq4&t=1228s) so much.
