AWS Bedrock · AgentCore · Production-ready
The operator's playbook for Bedrock agents that don't break production
229 pages on what AWS documentation won't tell you: Cedar policies, a reference architecture of eleven components, deterministic control, and the operations playbook for launching your first agent.
Companion code
Came here from the book? The code is right here.
Every listing in the twelve chapters lives in a public repository — Cedar policies, the reference architecture, and the deployment scripts. Free, no purchase required, no email asked.
Found something wrong, or an erratum? Open an issue — that's the fastest way to reach me, and I'd rather hear about it than not.
codecr/agentcore-production-playbook
The 2:37 AM problem
Your agent works perfectly in the demo. Production is a different story.
It's 2:37 AM. Your phone won't stop vibrating. The on-call dashboard is red. The DevOps agent you deployed last week — the one that worked flawlessly in staging — just dropped three production tables.
The agent didn't malfunction. It followed instructions perfectly. The problem was that nobody had defined what it should not do. No policy. No guardrails for destructive actions. No checkpoint between LLM reasoning and your production database.
This book is the manual nobody wrote for you. It's the difference between an AgentCore demo on YouTube and an agent your CTO trusts in production.
Every senior engineer I've talked to about Bedrock agents in production has the same story: the demo dazzled them, then reality cost them a weekend (or a customer).
— Gerardo Arroyo
Who this is for
Built for people who already chose AgentCore — or are about to.
This is for you if you are…
- A senior engineer or staff engineer building agents on Bedrock
- A cloud architect designing GenAI systems for an enterprise
- A tech lead responsible for getting an agent through a CTO review
- A DevOps/platform engineer deploying agents that touch production
- A founder building an AI product on AWS and tired of toy demos
Skip this if…
- You're new to AWS — start with foundational AWS material first
- You want a 30-minute LangChain tutorial — this is depth, not breadth
- You haven't decided on Bedrock vs OpenAI/Azure — this assumes Bedrock
- You expect no-code GUI walkthroughs — this is a manual, with real code
What's inside
12 chapters. 4 parts. 229 pages of operational depth.
Each chapter lands on a production-grade pattern with working code. No filler, no recycled blog posts pretending to be a book.
Part I · The Framing
Why prompts are not architecture, and the reference architecture the rest of the book unpacks.
- Why AgentCore Exists: The Real Problem with Agents in Production
- The Reference Architecture: Eleven Components, One Principle
Part II · Deterministic Control
The heart of the book. Cedar policies, Guardrails, Automated Reasoning.
- AgentCore Policy with Cedar: The Wall Outside the Reasoning Loop
- Bedrock Guardrails: The Model-Layer Companion to Policy
- Automated Reasoning: When “Probably Correct” Is Not Enough
Part III · State, Memory, and Knowledge
What the agent keeps, what it learns, and what it reads.
- Session Storage: What the Agent Built, Between One Session and the Next
- AgentCore Memory: What the Agent Has Learned
- Bedrock Knowledge Bases: What the Agent Reads, and How It Finds It
Part IV · Operation
Contracts, evaluation, governance at fleet scale, and day one.
- Structured Outputs: From Probable Shape to Guaranteed Shape
- Evaluations: Knowing Whether the Agent Is Any Good
- The Registry and the Trace: Governing a Fleet You Cannot See
- The Operations Playbook: Day One, and the Frontier
- Preface How to Read This Book
- Appendix The Eight Concerns, Mapped
What you actually get
Not a long blog post. A reference you'll keep open.
229 pages across 12 chapters and 4 parts — written as one argument, not a collection of tips
A reference architecture of eleven components, and the single principle that holds it together
Cedar policies read line by line: what each clause blocks, and what it quietly lets through
Working code in a public GitHub repository — clone it before you buy the book if you want
An appendix that maps the eight production concerns to the AgentCore feature that addresses each one
Trench notes: the errors that cost me nights, the ones whose message names nothing useful
Where to get it
Two formats, on Amazon, very soon.
The manuscript is finished and in review at Amazon. Leave your email and you'll be the first to know the day it goes live — no other email, nothing else.
Kindle edition
Read it anywhere, search it while you code.
- Instant delivery to any Kindle app or device
- Full-text search across all 12 chapters
- Adjustable type size for long code listings
- Included with Kindle Unlimited
Paperback
229 pages, 6 x 9, for the desk next to the keyboard.
- 229 pages, 6 x 9 in trim
- Print-optimized diagrams and code listings
- Annotate it, dog-ear it, take it to the architecture review
- Ships from your local Amazon
Get the launch note
One email, the day the book is live on Amazon. You'll land on my Cloud Chronicles list, which you can leave with one click.
The companion code is public and free, book or no book: github.com/codecr/agentcore-production-playbook
Frequently asked questions
If you're hesitating, these probably answer it.
Kindle or paperback — which one should I get?
Kindle if you’ll read it while you work: full-text search across 229 pages is hard to beat when you need to find the Cedar detail you half-remember. Paperback if you annotate margins and like the book open next to the keyboard. Diagrams and code listings are typeset for print, at 6 x 9 in.
Is it included in Kindle Unlimited?
Yes. The Kindle edition is enrolled in KDP Select, so if you have Kindle Unlimited you can read it at no extra cost.
Do I have to buy the code separately?
No. The companion repository is public and free, book or no book: github.com/codecr/agentcore-production-playbook. The book is the reasoning — why each piece sits where it sits, which trade-off you’re accepting, and what breaks when you pick the other option.
Is this a collection of your blog posts?
No. Several chapters grew out of research I also published on the blog, but the book is rewritten from scratch as one continuous argument: every chapter depends on the one before it and they all point at the same reference architecture. A post answers a question; the book answers what to do on Monday when an agent has to go to production. It’s 63,000 words, most of them new.
Do I need to be an AWS expert?
You need solid fundamentals: IAM, Lambda, and some hands-on time with Bedrock. If you’ve deployed a Bedrock agent before — even a basic one, even one that didn’t work — you’re exactly the audience. If you’re brand new to AWS, start with the official learning paths.
Does it cover the latest AgentCore features?
It covers what is generally available as of the publication date: AgentCore Policy with Cedar, Memory, Session Storage, Runtime, Evaluations, Agent Registry, Bedrock Guardrails, Automated Reasoning, Structured Outputs, and Knowledge Bases. AWS moves fast and the book assumes it: chapter 12 closes on the frontier, meaning what isn’t solved yet.
Does it replace the AWS documentation?
No, it complements it. The docs tell you what each feature does. The book tells you which ones to combine, in what order, with which patterns — and which decisions you’ll regret three months in. That part isn’t in any documentation, because nobody writes it down until it happens to them.
Can I read a sample first?
Yes, Amazon’s own: Look Inside on the paperback and the free Kindle preview, which includes the preface and the opening of chapter 1. The public repository also lets you judge the code before you decide.
Which Amazon storefronts sell it?
The ones KDP distributes to. Each storefront sets its own price and its own paperback shipping. Use the link on this page and Amazon will route you to your local store.
How can I support the book?
An honest review on Amazon. For a self-published technical book, reviews are the only real distribution mechanism — they’re what decides whether the next person searching for ‘AgentCore production’ ever finds it. Three lines help more than you’d think.
Ready when you are
The book is done. Amazon is reviewing it.
One email the day it goes live. In the meantime, the companion code is already public and the blog has the short versions of several chapters.