what is agentcore
aws bedrock agentcore is a managed runtime for production ai agents on aws — framework-agnostic (langgraph, strands, the vercel ai sdk all work), model-agnostic (any bedrock-resident model plus openai and anthropic via api keys), priced per invocation, with cold starts in the 3–8 second range. it ships seven primitives — runtime, memory, gateway, identity, browser, code interpreter, observability — that compose into the parts of an agent that normally take a quarter to build yourself. this course covers all of them, with running code.
who this is for
engineers who already ship typescript and now need to ship agents in production. you should be comfortable with async/await, http, and at least one llm api. you do not need an aws account, access to bedrock, or any prior agentcore experience — every lesson runs against a browser-side mock of the sdk that mirrors the real public surface. by the end of the course you'll be able to read a production agentcore codebase, reason about which primitive owns which problem, and write the deploy.
why mock, not real
cold starts and bedrock pricing make a real-aws teaching loop
slow and expensive. the mock removes both. the deliberate
constraint: every public function on the mock has the same
signature as its real counterpart, so the typescript you write
in lesson 02 is the typescript you'd commit to a production
repo. lesson 08 walks the diff explicitly — what changes when
you swap bedrock-agentcore-mock for the real
package, what doesn't, and the iam and region setup you'll
need on real aws.
how it works
- every lesson has a runnable typescript editor; types are stripped in-browser and the code executes in a module worker.
-
import { BedrockAgentCoreApp } from "bedrock-agentcore/runtime"resolves to a browser-side mock with the same public surface as the real sdk. - no network calls, no keys, no costs — the code you write is the code you'd ship, minus the deploy.
- lesson eight walks through the diff between mock and production.
lessons
- 01 what is agentcore the seven primitives, the boring parts aws decided to own, and the shape of a minimal agent. 10m
- 02 runtime — your first agent define an entrypoint, handle a payload, emit events. the agent app object, up close. 15m
- 03 memory — state that survives the turn session memory vs long-term memory. events, strategies, retrieval across sessions. 14m
- 04 gateway — turning apis into tools take an openapi spec (or a lambda) and make it callable from your agent as an mcp tool. 16m
- 05 identity — inbound and outbound auth workload identity, oauth to third parties, iam without writing policy by hand. 14m
- 06 browser & code interpreter two managed tools you get for free — when to reach for each. 12m
- 07 observability — reading the trace spans, tool-call boundaries, cost attribution. the parts cloudwatch doesn't show you. 10m
- 08 shipping to real aws what changes when you leave the sandbox. cli, iam, costs, and the smallest deploy that works. 18m