<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: AWS</title>
    <description>The latest articles on DEV Community by AWS (aws).</description>
    <link>https://dev.to/aws</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Forganization%2Fprofile_image%2F1726%2F2a73f1e6-7995-4348-ae37-44b064274c59.png</url>
      <title>DEV Community: AWS</title>
      <link>https://dev.to/aws</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/aws"/>
    <language>en</language>
    <item>
      <title>How to pick AWS storage (without reading every doc)</title>
      <dc:creator>Athena Wemmert</dc:creator>
      <pubDate>Wed, 18 Nov 2026 21:32:10 +0000</pubDate>
      <link>https://dev.to/aws/how-to-pick-aws-storage-without-reading-every-doc-hfm</link>
      <guid>https://dev.to/aws/how-to-pick-aws-storage-without-reading-every-doc-hfm</guid>
      <description>&lt;p&gt;If you've ever needed to save data on AWS and had no idea which storage to pick, I feel you. There are a lot of choices, and it's completely okay not to know what they all do. Luckily for you, you don't need to. You just need to answer five questions, in order.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 1: How does your app get to the data?
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzi64ez9e1ee5kk64cwgk.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzi64ez9e1ee5kk64cwgk.png" alt=" " width="800" height="450"&gt;&lt;/a&gt;&lt;br&gt;
Every AWS storage service fits into one of three groups, and each group matches a way your app reaches its data:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Object storage&lt;/strong&gt; (Amazon S3): your app talks to it over an API.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;File storage&lt;/strong&gt; (Amazon EFS, Amazon FSx, S3 Files): your app opens files by path, over a file protocol like NFS or SMB.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Block storage&lt;/strong&gt; (Amazon EBS): it attaches to a server like a disk.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If you already know how your app reads and writes data, you've pretty much cut your options down to one group.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 2: What shape is your data?
&lt;/h2&gt;

&lt;p&gt;The shape of your data narrows things down before you ever look at speed or price.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Your data&lt;/th&gt;
&lt;th&gt;Where it fits&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Images, video, logs, backups&lt;/td&gt;
&lt;td&gt;S3 general purpose buckets&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tables you query with SQL&lt;/td&gt;
&lt;td&gt;S3 Tables&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Vector embeddings for similarity search&lt;/td&gt;
&lt;td&gt;S3 Vectors&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Files in folders that apps open by path&lt;/td&gt;
&lt;td&gt;EFS, S3 Files or FSx&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Raw disk for a database or boot drive&lt;/td&gt;
&lt;td&gt;EBS&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  Step 3: Is this a new app or one you already have?
&lt;/h2&gt;

&lt;p&gt;If it's a new app, go with what you found in steps 1 and 2. Services where you don't have to set up storage space ahead of time, like S3, EFS and S3 Files, mean less work for you later.&lt;/p&gt;

&lt;p&gt;If you're moving an app you already have, the system it runs on today usually tells you where to go:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Your app runs on&lt;/th&gt;
&lt;th&gt;Move it to&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;NetApp ONTAP&lt;/td&gt;
&lt;td&gt;FSx for NetApp ONTAP&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ZFS&lt;/td&gt;
&lt;td&gt;FSx for OpenZFS&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Windows File Server&lt;/td&gt;
&lt;td&gt;FSx for Windows File Server&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Lustre&lt;/td&gt;
&lt;td&gt;FSx for Lustre&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Apache Hive tables on S3&lt;/td&gt;
&lt;td&gt;S3 Tables (it can convert them to Apache Iceberg for you)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;To move the data itself, use &lt;a href="https://docs.aws.amazon.com/datasync/latest/userguide/what-is-datasync.html?trk=9e3deed6-59ef-4b79-b0e4-a5bb2e107411&amp;amp;sc_channel=el" rel="noopener noreferrer"&gt;AWS DataSync&lt;/a&gt; for online transfers, or &lt;a href="https://docs.aws.amazon.com/datatransferterminal/latest/userguide/what-is-dtt.html?trk=9e3deed6-59ef-4b79-b0e4-a5bb2e107411&amp;amp;sc_channel=el" rel="noopener noreferrer"&gt;AWS Data Transfer Terminal&lt;/a&gt; for physical transfers.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 4: Do two kinds of apps need the same data?
&lt;/h2&gt;

&lt;p&gt;This is the part I didn't know before. Sometimes your data lives in one kind of storage, but an app needs to reach it a different way. Say your data is in an S3 bucket, but one of your tools can only open files from a folder. You don't have to copy the data over. A couple of features give that tool its own way to reach the same data:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Your data lives in&lt;/th&gt;
&lt;th&gt;Your app also needs&lt;/th&gt;
&lt;th&gt;Use&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;An S3 bucket&lt;/td&gt;
&lt;td&gt;File access over NFS&lt;/td&gt;
&lt;td&gt;S3 Files&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;FSx for NetApp ONTAP or OpenZFS&lt;/td&gt;
&lt;td&gt;Access through the S3 API, without copying data&lt;/td&gt;
&lt;td&gt;S3 Access Points for FSx&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;So when do you pick S3 Files over EFS? Choose S3 Files when your data already lives in S3 and also needs to be opened by path. Choose EFS when the file system is the main home for your data.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 5: Building with AI or agents?
&lt;/h2&gt;

&lt;p&gt;Match storage to each step of the work:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzqlx85bfbhutlwpfok0n.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzqlx85bfbhutlwpfok0n.png" alt=" " width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Training data:&lt;/strong&gt; S3, S3 Files, EFS, or FSx for Lustre when lots of servers read at once.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Fast training and running models:&lt;/strong&gt; S3 Express One Zone, for single-digit millisecond reads on data you use a lot.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;RAG and semantic search:&lt;/strong&gt; S3 Vectors. You can also pick it as the vector store for Amazon Bedrock Knowledge Bases.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Agent memory:&lt;/strong&gt; S3 Vectors, so an agent can save embeddings and pull back related context.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Helping agents find data:&lt;/strong&gt; S3 Metadata keeps an always-updated table of everything in a bucket for you, so you don't have to build one. S3 annotations add business context so agents can find the right files.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Agents that expect a file system:&lt;/strong&gt; EFS or S3 Files. Amazon EC2, AWS Lambda, Amazon ECS and Amazon EKS can all mount S3 Files.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  And always, how much is this going to cost?
&lt;/h2&gt;

&lt;p&gt;Once you're down to one or two options, compare price. Each service has its own pricing page: &lt;a href="https://aws.amazon.com/s3/pricing/?trk=9e3deed6-59ef-4b79-b0e4-a5bb2e107411&amp;amp;sc_channel=el" rel="noopener noreferrer"&gt;S3&lt;/a&gt;, &lt;a href="https://aws.amazon.com/efs/pricing/?trk=9e3deed6-59ef-4b79-b0e4-a5bb2e107411&amp;amp;sc_channel=el" rel="noopener noreferrer"&gt;EFS&lt;/a&gt;, &lt;a href="https://aws.amazon.com/ebs/pricing/?trk=9e3deed6-59ef-4b79-b0e4-a5bb2e107411&amp;amp;sc_channel=el" rel="noopener noreferrer"&gt;EBS&lt;/a&gt; and &lt;a href="https://aws.amazon.com/fsx/pricing/?trk=9e3deed6-59ef-4b79-b0e4-a5bb2e107411&amp;amp;sc_channel=el" rel="noopener noreferrer"&gt;FSx&lt;/a&gt;. To guess your monthly bill, plug your numbers into the &lt;a href="https://calculator.aws/" rel="noopener noreferrer"&gt;AWS Pricing Calculator&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;If you don't know how often your data gets read, S3 Intelligent-Tiering moves it between access tiers for you, and S3 Tables supports those tiers for table data too.&lt;/p&gt;

&lt;h2&gt;
  
  
  The quick version
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;If your app...&lt;/th&gt;
&lt;th&gt;Look at&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Talks to data over an API&lt;/td&gt;
&lt;td&gt;S3&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Opens files by folder path&lt;/td&gt;
&lt;td&gt;EFS, S3 Files or FSx&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Needs a disk attached to a server&lt;/td&gt;
&lt;td&gt;EBS&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Stores tables you query with SQL&lt;/td&gt;
&lt;td&gt;S3 Tables&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Stores embeddings for similarity search&lt;/td&gt;
&lt;td&gt;S3 Vectors&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Needs single-digit millisecond reads&lt;/td&gt;
&lt;td&gt;S3 Express One Zone&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Has data in S3 but needs to open it as files&lt;/td&gt;
&lt;td&gt;S3 Files&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Runs on NetApp ONTAP, ZFS, Windows File Server or Lustre today&lt;/td&gt;
&lt;td&gt;The matching FSx&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  Where to go next
&lt;/h2&gt;

&lt;p&gt;Did any of this not make sense at first? It didn't for me either, until I sat crying underneath a pile of documentation. The good news is you only need step 1 to get started, and the rest follows.&lt;/p&gt;

&lt;p&gt;If you build with a coding agent, the &lt;a href="https://github.com/aws/agent-toolkit-for-aws/blob/main/skills/core-skills/aws-storage/SKILL.md" rel="noopener noreferrer"&gt;aws-storage&lt;/a&gt; skill in the Agent Toolkit for AWS gives your agent these same rules, so it picks the right storage for you too.&lt;/p&gt;

</description>
      <category>aws</category>
      <category>storage</category>
      <category>ai</category>
      <category>beginners</category>
    </item>
    <item>
      <title>How to Write Compelling Technical Blogs</title>
      <dc:creator>Ifeanyi O.</dc:creator>
      <pubDate>Wed, 18 Nov 2026 20:37:14 +0000</pubDate>
      <link>https://dev.to/aws/how-to-write-compelling-technical-blogs-4ohh</link>
      <guid>https://dev.to/aws/how-to-write-compelling-technical-blogs-4ohh</guid>
      <description>&lt;h2&gt;
  
  
  Intro
&lt;/h2&gt;

&lt;p&gt;Most technical writers spend a lot of time writing a blog full of complex technical topics and jargon but lose their readers before the third paragraph.&lt;/p&gt;

&lt;p&gt;This is because many technical writers focus so much on technical accuracy, that they end up only writing from their perspective and forget to put themselves in the shoes of the reader. They forget to answer the million dollar question a reader is asking:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"Why should I spend my time reading this?"&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Your audience has a very short attention span and unfortunately, fewer and fewer people are compelled to read these days (OPEN THE SCHOOLS!). So you need to write with this reality in mind.&lt;/p&gt;

&lt;p&gt;Having read a lot of compelling technical blogs, I've noticed they tend to follow recognizable patterns and incorporate similar elements. Some I've noted and incorporate into my writing include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Begins with a subject the writer genuinely cares about&lt;/li&gt;
&lt;li&gt;Subject is written as a story rather than technical documentation&lt;/li&gt;
&lt;li&gt;Assumptions of the reader are stated early&lt;/li&gt;
&lt;li&gt;Incorporates different real world scenarios&lt;/li&gt;
&lt;li&gt;Demonstrates claims instead of just stating them&lt;/li&gt;
&lt;li&gt;Utilizes images, videos, gifs and other forms of communication&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;In this article, I'll walk through these patterns and focus on what each component does and how they reinforce one another. I'll also try to apply them throughout, so you can observe each technique in the same section where I describe it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Part 1. Choosing a Subject You Find Compelling
&lt;/h2&gt;

&lt;p&gt;The first decision a writer makes is what to write about, but many go about selecting that the wrong way. Their instinct is to select a topic they expect to perform well rather than a subject they are actually excited to talk about.&lt;/p&gt;

&lt;p&gt;Enthusiasm is one component of writing that cannot be manufactured. A reader detects its absence within the first couple paragraphs, so it just reads as a flat encyclopedia voice where even though the information is factual, it doesn't appeal to them in any way.&lt;/p&gt;

&lt;p&gt;The alternative is to write on whatever is compelling to you. Even if the subject has already been covered, the fact that you have a personal stake of passion in the topic will show in the writing and immediately differentiate you from others. That's why your most compelling blogs tend to come from your most recent experiences.&lt;/p&gt;

&lt;p&gt;A subject learned last week will most likely produce better writing than a subject mastered five years ago. Deep familiarity removes access to what unfamiliarity felt like, which is why it's very easy for experienced engineers to produce less followable tutorials. However, a newbie learning for the first time tends to be able to convey their experience in a very captivating way.&lt;/p&gt;

&lt;p&gt;A writer who solved a problem recently still vividly remembers the details of their experience. That memory and the emotions behind it tend to fade away as time goes on.&lt;/p&gt;

&lt;h2&gt;
  
  
  Part 2. Framing the Subject as a Story
&lt;/h2&gt;

&lt;p&gt;Most technical blogs openings are just definitions:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"Amazon S3 is an object storage service that offers industry leading scalability."&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;But that's a sentence a reader will never willingly read in an intro, because it contains no stakes, no personality and no reason to occupy the top of a page.&lt;/p&gt;

&lt;p&gt;Consider an alternative opening:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;A $400 bill hit your email for a static website that served two hundred visitors.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Take a moment to process what you felt when you read each opening and come to your own conclusion.&lt;/p&gt;

&lt;p&gt;Storytelling in technical writing is not decoration and does not require inventing drama. It requires just three things.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;A person, someone with a problem, a constraint and something at stake, usually the writer. A sentence as plain as "this took two days to work out" is among the most generous in technical writing, because it conveys to the reader the difficulty so they don't get discouraged themselves.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Addressing a wrong turn. A tutorial where every command succeeds on the first attempt becomes useless as soon as the reader runs into an issue of their own. Addressing known failed approaches can sometimes be worth more than the one that worked, because a reader is able to gain understanding and a path forward. It also establishes credibility, since anyone can publish a path that worked.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;An arc. Something was broken or unclear, so the writer pursued it, and here is where it ended and what it cost. As simple as that is, it works and is a reason readers will continue to the end.&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The same principle applies at the paragraph level. Every section should open with a reason to care before it opens with information.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;em&gt;"Security groups are stateful firewalls attached at the instance level"&lt;/em&gt; - states a fact.&lt;/li&gt;
&lt;li&gt;
&lt;em&gt;"This is the first thing to check when an instance is running and still refuses connections" - s&lt;/em&gt;tates the same fact but making you want to continue reading to know more.
&amp;nbsp;
A narrative gives the reader a reason to keep reading, and how you structure it determines whether the reader can follow.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Part 3. Deciding the Shape Before Writing
&lt;/h2&gt;

&lt;p&gt;A simple step many writers skip is the outline, which is why many articles wander. Before you just start writing, you should have a heading template that structures the blog into a logical picture you're about to paint to the reader. Reading only those headings from top to bottom will reveal whether the post is telling the right story.&lt;/p&gt;

&lt;p&gt;Weak headings look like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Introduction
Background
Setup
Implementation
Conclusion
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That is just a filing system rather than the flow of a story. It doesn't give the writer or reader any insight into what they are about to write or read.&lt;br&gt;
&amp;nbsp;&lt;br&gt;
Stronger headings look like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;The $400 bill
Confusion behind CloudFront caching
Setting up the distribution
Tracing a single request
What I would do differently
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Each one gives you some information about what you are getting into, and read in sequence that already summarize the blog. Once the shape is settled, you have a high level guide of what each component of that shape has to accomplish for the reader.&lt;/p&gt;

&lt;h2&gt;
  
  
  Part 4. Stating Your Assumptions Early
&lt;/h2&gt;

&lt;p&gt;Telling someone they need "basic AWS knowledge" is so vague that it's not worth communicating. Be specific. Telling them they "&lt;em&gt;should have deployed at least one Lambda function&lt;/em&gt;" gives them something tangible.&lt;/p&gt;

&lt;p&gt;The same goes for your tools and versions, because Python 3.11, Node 20 and AWS CLI v2 all behave differently from the versions that came before them and your reader has no way of guessing which ones you used.&lt;/p&gt;

&lt;p&gt;Spell out the access you expect them to have as well, whether that is an admin account, a specific set of permissions or a domain they already own.&lt;/p&gt;

&lt;p&gt;Two things get left out of almost every prerequisites section:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Time and money. Saying that something "&lt;em&gt;takes about 30 minutes and will cost roughly $2 if they leave it running overnight&lt;/em&gt;" respects the reader enough to let them decide, and an unexpected bill is the quickest way to lose their trust... permanently.&lt;/li&gt;
&lt;li&gt;What the post does not cover. This is the quickest way to stop the wrong reader from reading an article they didn't need.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;All of that costs a reader about twelve seconds and saves the wrong reader ten minutes. Now, once they know the post is written for them, they need something concrete to follow.&lt;/p&gt;

&lt;h2&gt;
  
  
  Part 5. Grounding it in Real World Scenarios
&lt;/h2&gt;

&lt;p&gt;An explanation that stays abstract adds friction to the understanding of the reader who has never seen the thing before. Real world scenarios help make your explanation... realistic, inviting the reader to better envision themselves in the story. This can be done in many ways.&lt;/p&gt;

&lt;p&gt;Some writers state a scenario early and let it run through the entire piece. For example, the same broken deployment is incorporated in every section and each new concept is introduced by what it does to that one situation. This works especially well for tutorials and deep dives, because the reader ends up building a single mental model instead of several disconnected ones.&lt;/p&gt;

&lt;p&gt;Other times you are better off placing a different scenario in each section, which tends to happen when the concepts you're explaining do not naturally belong to the same story. A section on security groups might open with an instance that's running but refusing connections, while a section on NAT gateways can open with a private service that needs to download a package. Each scenario plays its role within that section.&lt;/p&gt;

&lt;p&gt;You can also interweave the two approaches, anchoring the post in one main story while dropping smaller examples wherever a point needs support. What matters is less about which approach you choose and more that the reader is kept engaged through a scenario they recognize.&lt;/p&gt;

&lt;p&gt;A good scenario is small enough to hold in your head and close enough to reality to feel familiar. Once the reader has a situation they recognize, the next thing they need from you is a path through it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Part 5. Walking Through It Step by Step
&lt;/h2&gt;

&lt;p&gt;A walk through is where most of the practical value of a technical blog lives, so you'd want to be almost mechanical about how you lay it out. Number the steps, because a reader returning a day later is looking for a specific step and needs to find it quickly.&lt;/p&gt;

&lt;p&gt;Keep each step to a single action and include where the reader is meant to be at each point, whether that is a directory, a console page or a particular file, because just saying "&lt;em&gt;add this to the handler"&lt;/em&gt; assumes they already have your project open in front of them.&lt;/p&gt;

&lt;p&gt;Everything in the post also needs to run exactly as written. A &lt;code&gt;&amp;lt;your-region&amp;gt;&lt;/code&gt;with no explanation of what belongs there, or an abbreviated snippet with a comment standing in for the real code will break the reader's flow.&lt;/p&gt;

&lt;p&gt;Additionally, make sure to show expected output after every step. This turns each step into a checkpoint where the reader can confirm they're still on track, so they catch a problem when it happens rather than discovering it at several steps later. You'd want to name the failures you ran into yourself too, something as simple as telling them that "an &lt;em&gt;&lt;code&gt;AccessDenied&lt;/code&gt;response here means their role is missing&lt;code&gt;s3:PutObject&lt;/code&gt;&lt;/em&gt;" can save your reader an hour of trying to figure it out themselves.&lt;/p&gt;

&lt;p&gt;A clear walk through will get the reader to the end, but what makes them trust it is the evidence you put in front of them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Part 6. Show, Don't Just Tell
&lt;/h2&gt;

&lt;p&gt;The difference between technical writing people trust and technical writing people second guess usually comes down to whether the claims in it can be checked.&lt;/p&gt;

&lt;p&gt;Writing that something is "really fast" is vague and makes the read question your claims because they have no way of verifying that. However, if you state and show actually numbers like, "p99 latency dropped from 840ms to 62ms" it gives the reader a number they can later evaluate themselves. It also subconsciously makes them lean more into trusting you because of your transparency.&lt;/p&gt;

&lt;p&gt;In practice this means pasting real output rather than describing it, including the parts that can look messy, like stack traces, error strings and durations.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Did you know that someone searching for the exact error message you included is one of the most common ways your blog gets found in the first place?&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;It also means showing the difference instead of a summary of it, because "&lt;em&gt;I updated the handler to parse the body&lt;/em&gt;" is shorter and far less useful than showing the four lines that you actually changed.&lt;/p&gt;

&lt;p&gt;This logic also applies in both directions. When you tell the reader something is difficult, show them the difficult part so they can see what they are up against and when you tell them it's simple, show the simplicity of it so they can see how short it really is. Give power to the reader to make decisions.&lt;/p&gt;

&lt;p&gt;Some things cannot be proven in a sentence though, which is where visuals come in.&lt;/p&gt;

&lt;h2&gt;
  
  
  Part 7. Break Up the Text With Visuals
&lt;/h2&gt;

&lt;p&gt;People just don't like reading blocks of text anymore so use visuals to break it up. The right visual helps you communicate at a level text could never do. Ironically, there are no images in this blog :)&lt;/p&gt;

&lt;p&gt;Diagrams carry anything with more than two moving parts, so if you catch yourself writing something like, &lt;em&gt;"the request goes from the load balancer to the service, which writes to a queue, which a worker then picks up,"&lt;/em&gt; you just wrote a diagram you have not drawn yet.&lt;/p&gt;

&lt;p&gt;Screenshots cover anything involving an interface, but make sure they are annotated! A bare console screenshot will leave a reader hunting for whatever it is you are describing. Box the field, add an arrow and tell them what to look at.&lt;/p&gt;

&lt;p&gt;Fifteen to thirty seconds of video, or a GIF, gives readers a break by changing their consumption method to being more passive and offering you the opportunity to be lot more creative in delivery.&lt;/p&gt;

&lt;p&gt;Two rules to abide by here:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Never screenshot code, since it cannot be copied, searched or read properly on a phone&lt;/li&gt;
&lt;li&gt;Always write alt text that describes what the image shows rather than what it is&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;If you only make one visual for a post, make it a diagram of your scenario. That is the image people screenshot and share, which makes it the one that will carry your post to places you can't reach yourself.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where to Go From Here
&lt;/h2&gt;

&lt;p&gt;Pick the thing you can't stop thinking or talking about. Think about the story you want to tell and sketch out the headings, state what you're assuming, thread in real world scenarios, include any steps, show the output and try you're best to include images.&lt;/p&gt;

&lt;p&gt;When you're doing your final read, there's really only one question to ask:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"Is this worth spending my time reading?"&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;If the answer is yes, publish it!&lt;br&gt;
&amp;nbsp;&lt;/p&gt;

&lt;p&gt;Authored by:&lt;br&gt;
&lt;a href="https://www.linkedin.com/in/ifeanyiotuonye/" rel="noopener noreferrer"&gt;&lt;strong&gt;Ifeanyi Otuonye&lt;/strong&gt;&lt;/a&gt; Developer Experience Engineer, AWS&lt;/p&gt;

</description>
      <category>learning</category>
      <category>writing</category>
    </item>
    <item>
      <title>Understanding an Unfamiliar Codebase with Kiro Crew bots</title>
      <dc:creator>Laura Salinas</dc:creator>
      <pubDate>Wed, 18 Nov 2026 17:44:13 +0000</pubDate>
      <link>https://dev.to/aws/understanding-an-unfamiliar-codebase-with-kiro-crew-bots-1gkg</link>
      <guid>https://dev.to/aws/understanding-an-unfamiliar-codebase-with-kiro-crew-bots-1gkg</guid>
      <description>&lt;p&gt;We've all been there. You clone a repo you're excited about, open it up, and you're greeted by a README, 40 top-level folders and absolutely no map. You start clicking around, open a few files that look important, and 45 minutes later you're still not sure where anything actually starts 😅&lt;/p&gt;

&lt;p&gt;I've been experimenting with Kiro Crew bots and wanted to take them for a run on a new codebase. For this post we're using the open source &lt;a href="https://github.com/heygen-com/hyperframes" rel="noopener noreferrer"&gt;HyperFrames&lt;/a&gt; project by HeyGen. &lt;/p&gt;

&lt;p&gt;It gives users and agents alike the ability to turn HTML, CSS and seekable animations into deterministic MP4s. It's interesting, it's active, and it's big enough to be a little intimidating (perfect test for our Crew bots).&lt;/p&gt;

&lt;p&gt;In this post I'll walk you through how I went from a fresh clone to an architecture map and a list of good first issues to contribute in about 10 minutes end to end.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is a bot?
&lt;/h2&gt;

&lt;p&gt;For those who haven't tried Kiro Crew yet, it is a persistent, open source development workspace that remembers your context and learns how you work. It runs locally or remotely on your own hardware.&lt;/p&gt;

&lt;p&gt;On Nov 5th Kiro introduced &lt;strong&gt;bots&lt;/strong&gt;. They're named teammates with their own thread, own memory and their own dashboard that sticks around between sessions.&lt;/p&gt;

&lt;p&gt;You can think of it as the difference between a front desk and a workshop. The bot sits at the front desk: it takes your request, plans the work and reviews what comes back. The actual deep reading happens in the workshop, where parallel worker sessions each take a slice of the problem.&lt;/p&gt;

&lt;p&gt;Key characteristics:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Persistent memory&lt;/strong&gt;: What the bot learns about the repo today is still there tomorrow.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Parallel workers&lt;/strong&gt;: Instead of one session reading the whole repo top to bottom, several workers dive deep into different areas at once.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tracked items&lt;/strong&gt;: Each investigation is an item with an acceptance bar, so you're not stuck trusting a vague "done, looks good."&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Setting up the bot 🔨
&lt;/h2&gt;

&lt;p&gt;The setup is pretty straightforward. First we'll clone the repo we want the bot to help us understand, and then we can create the bot in the Crew desktop client to get started.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Step 1: Clone HyperFrames&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git clone https://github.com/heygen-com/hyperframes.git
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Step 2: Create the bot&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;From the Kiro Crew desktop client click on &lt;strong&gt;Bots&lt;/strong&gt; to start creation.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9s8my95tun04q9666nof.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9s8my95tun04q9666nof.png" alt=" " width="434" height="318"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;I named mine "HyperFrames Guide" and pointed its workspace at my local clone.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fm5ath6ecradygbzos8cc.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fm5ath6ecradygbzos8cc.png" alt=" " width="535" height="943"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/m7LDzTWKiwc" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Step 3: Give it a one-sentence goal&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Here's the exact goal I used:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"Help me understand this codebase well enough to make my first contribution."&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpaq9c2igjn3wpjt2je67.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpaq9c2igjn3wpjt2je67.png" alt=" " width="773" height="321"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;One thing worth mentioning: I chose to keep this simple and avoid writing a paragraph here. A tight goal gives the bot a clear finish line, and it does a much better job of breaking work down when it's not guessing what you meant.&lt;/p&gt;

&lt;p&gt;Rather than charging off and reading every file, the bot breaks the initial goal into separate tracked items, each with its own acceptance condition. It wasn't just splitting up the work, it was creating an understanding of what "done" would actually look like for each piece.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9bmh168r5g1uygvzfb4s.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9bmh168r5g1uygvzfb4s.png" alt=" " width="607" height="393"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The Payoff
&lt;/h2&gt;

&lt;p&gt;With my goal in mind, the bot went off and 3 minutes later returned with a detailed report of the HyperFrames repo that I could share with peers, and a plan for my first contribution. &lt;/p&gt;

&lt;p&gt;What I liked most is that the bot's &lt;strong&gt;Dashboard tab&lt;/strong&gt; turned into a living onboarding page. Instead of scrolling back through a long chat to find that one useful answer, I can open the dashboard and everything is right there. It maintains the running list of milestones for our shared goal and keeps me updated on what the agent is working on vs what I should be working on. &lt;/p&gt;

&lt;p&gt;This process felt like a nice balance of having a teammate alongside you that can be given a direct task, while also maintaining a collaborative symbiosis and transparency into what the agent was actually doing. &lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fo9ugg2zr0txwoychiasq.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fo9ugg2zr0txwoychiasq.png" alt=" " width="800" height="820"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Day two: Coming back to progress
&lt;/h2&gt;

&lt;p&gt;Let's say I stopped there for day one. When I come back to my bot the following day I can pick up where we left off by continuing in the chat. &lt;/p&gt;

&lt;p&gt;No re-scanning the repo, no re-explaining what HyperFrames is. It answered from what it already knew, the same way a teammate who onboarded with you would. In practice this is the thing that saves the most time working alongside an agent. &lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/ZwMA0yhh4lA" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;h2&gt;
  
  
  Rough edges 😵‍💫
&lt;/h2&gt;

&lt;p&gt;It wasn't all smooth sailing, and I think it's worth calling out where I got tripped up.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The bot went idle after milestone approval&lt;/strong&gt;. After I approved the bot's goal, it suggested a set of milestones, which I also approved. I expected it to start working right away, but instead it just sat idle waiting for me to prompt it to continue. As a user this was confusing, since the whole point of a bot is unattended work that follows a goal. A quick "go ahead and start" message got it moving again, so if you hit the same thing, give it a nudge.&lt;/p&gt;

&lt;p&gt;I've shared this with the Kiro team as product feedback, so hopefully it's smoother by the time you try it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it yourself
&lt;/h2&gt;

&lt;p&gt;Here's a short checklist to try this on any repo:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Clone the repo locally&lt;/li&gt;
&lt;li&gt;Create a Crew bot and point its workspace at the clone&lt;/li&gt;
&lt;li&gt;Give it a one-sentence goal&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;From my exploration of this workflow, here are some best practices:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Keep the goal small&lt;/strong&gt;: "Make my first contribution" works better than "understand everything."&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Let it track separate items&lt;/strong&gt;: Separate items mean separate acceptance bars, which means fewer hand-wavy answers.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Read the dashboard, not the chat&lt;/strong&gt;: The dashboard is your one stop shop.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Come back with follow-ups&lt;/strong&gt;: The value shows up as you continue to use the bot over time, so use its memory!&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Final Takeaway
&lt;/h2&gt;

&lt;p&gt;What would normally take me the better part of an afternoon (and a lot of googling) came down to roughly 10 minutes and a report I can actually come back to. This same pattern works beyond open source onboarding. Think inheriting a service from another team, ramping up during an incident or reviewing a really large PR. All of these tasks can be done in collaboration with your Crew bot. &lt;/p&gt;

&lt;p&gt;Don't forget to give me a 🦄 if you got this far and let me know what repo you're looking to dive deep on in the comments!&lt;/p&gt;

&lt;h2&gt;
  
  
  Additional Resources 📚
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://kiro.dev/crew/?trk=c6a9670e-a495-43a4-85ae-16eae0a1aadc&amp;amp;sc_channel=el" rel="noopener noreferrer"&gt;Download Kiro Crew&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://kiro.dev/blog/crew-bots/?trk=c6a9670e-a495-43a4-85ae-16eae0a1aadc&amp;amp;sc_channel=el" rel="noopener noreferrer"&gt;Kiro Crew bot Announcement&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://kiro.dev/docs/crew/bots/?trk=c6a9670e-a495-43a4-85ae-16eae0a1aadc&amp;amp;sc_channel=el" rel="noopener noreferrer"&gt;Kiro Crew bot Documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/heygen-com/hyperframes" rel="noopener noreferrer"&gt;HyperFrames on GitHub&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>learning</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>Let's Strands Decider our Role-Playing Game</title>
      <dc:creator>TheWitcherish</dc:creator>
      <pubDate>Wed, 18 Nov 2026 09:03:35 +0000</pubDate>
      <link>https://dev.to/aws/lets-strands-decider-our-role-playing-game-489e</link>
      <guid>https://dev.to/aws/lets-strands-decider-our-role-playing-game-489e</guid>
      <description>&lt;p&gt;If you build agents that call tools, you can let them act when they're sure and ask when they're not.&lt;br&gt;
That is the job &lt;a href="https://github.com/strands-labs/strands-decider" rel="noopener noreferrer"&gt;Strands Decider&lt;/a&gt; does. It is a small decision model that answers a typed question (yes/no, pick one, or a score) in a few hundred milliseconds on a laptop. &lt;/p&gt;

&lt;p&gt;&lt;a href="https://dev.to/thewitcherish/series/46409"&gt;re:Using our Once Upon Agentic AI Series' Articles&lt;/a&gt;, let's play with Strands Decider to give our AI Game Master three useful reactions: commit to an answer, ask the player first, or pick the right specialist agent before answering.&lt;/p&gt;
&lt;h2&gt;
  
  
  Getting Started
&lt;/h2&gt;

&lt;p&gt;You need a terminal and &lt;a href="https://docs.astral.sh/uv/getting-started/installation/" rel="noopener noreferrer"&gt;uv&lt;/a&gt;, the Python package and project manager. No uv yet? Its install page has a one-line installer for macOS, Linux and Windows, and uv fetches the right Python for you. Clone the sample, install its dependencies, and start the model server:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git clone https://github.com/TheWitcherish/sample-strands-decider-rpg
&lt;span class="nb"&gt;cd&lt;/span&gt; sample-strands-decider-rpg
uv sync

&lt;span class="c"&gt;# terminal 1: the model server (leave it running)&lt;/span&gt;
&lt;span class="kd"&gt;export&lt;/span&gt; &lt;span class="nv"&gt;DECIDER_MODEL&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;StrandsAgents/strands-decider-2B-qwen3.5-v1-2610
uv run --extra decider strands-decider serve &lt;span class="s2"&gt;"$DECIDER_MODEL"&lt;/span&gt; --port 8000
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The first start installs the model runtime and downloads about 4 GB of model weights, and it runs on Apple silicon, an NVIDIA GPU, or CPU. It is ready when it prints &lt;code&gt;Uvicorn running on http://127.0.0.1:8000&lt;/code&gt;. Leave that terminal open, open a second terminal in the same folder for every command below, and stop the server with Ctrl+C when you are done. Model identifiers change, so check the current one in the &lt;a href="https://github.com/strands-labs/strands-decider" rel="noopener noreferrer"&gt;Strands Decider README&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Every &lt;code&gt;once-upon-strands-decider&lt;/code&gt; command below sends its question to this server, and &lt;code&gt;--say&lt;/code&gt; lets you put your own words in your character's mouth.&amp;nbsp;&lt;/p&gt;

&lt;h2&gt;
  
  
  Yes/no: act only when the confidence clears your bar
&lt;/h2&gt;

&lt;p&gt;First, a word on the bar. Strands Decider hands back an answer and a confidence between &lt;code&gt;0&lt;/code&gt; and &lt;code&gt;1&lt;/code&gt;; whether your app acts on that answer is your call, not the model's. The bar is the confidence your code requires before it acts, and you, the developer, set it: the model never sees it. In this sample it is one constant, &lt;code&gt;CONFIDENCE_BAR = 0.8&lt;/code&gt; in &lt;code&gt;engine.py&lt;/code&gt;, and &lt;code&gt;--bar&lt;/code&gt; overrides it for a run. Above the bar, the AI Game Master acts on the answer; below it, it asks the player.&lt;/p&gt;

&lt;p&gt;Chapter 1 asks one yes/no question: does the action need a perception check, a roll to notice something? This is the whole decision, from &lt;code&gt;chapters.py&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="no"&gt;CH1_Q&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Final&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;YesNoQuestion&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"needs_check"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;instructions&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"Does the adventurer's action call for a perception check, a roll to notice?"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;criteria&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="s2"&gt;"true"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"The adventurer actively stops, looks, listens or heads toward the sound"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="s2"&gt;"false"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"The adventurer chooses to ignore the sound and carries on without looking"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;acted&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;answer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;confidence&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;=&lt;/span&gt; &lt;span class="n"&gt;bar&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The &lt;code&gt;criteria&lt;/code&gt; say what counts as yes and as no. The routing is one line: &lt;code&gt;acted = answer.confidence &amp;gt;= bar&lt;/code&gt;. Strands Decider never rolls the dice. It only answers whether a roll is needed; the d6 is a few lines of plain Python with a seed, so the same run always rolls the same number. Run it in the second terminal and guess first: will the AI Game Master roll, or ask you?&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;uv run once-upon-strands-decider chapter 1
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;  adventurer : "Wait, what was that? I stop and look toward the sound."
  decider    : needs_check -&amp;gt; yes (p_yes=0.929)
  evidence   : perception check -&amp;gt; needs 4+; the d6 shows 3
  confidence : 0.857 (bar 0.80) -&amp;gt; ACTED
  speed      : 1 round trip(s), 180 ms on strands-decider-2B-qwen3.5-v1-2610
  The d6 lands short of the number. Something big steps out of the brambles, and it saw you first: a bramblehoot, a bear with an owl's face.
&amp;gt;&amp;gt;&amp;gt; Face to Beak: It tilts its head all the way sideways and hoots. You decide that was hello.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Stopping to look is clearly a check: the model answers yes at &lt;code&gt;0.857&lt;/code&gt;, clears the bar, and the d6 rolls. A 3 misses the 4+, and TheWitcherish meets a creature he has never seen before. The bramblehoot is right in front of him now, so he tries the friendliest thing he knows:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;uv run once-upon-strands-decider chapter 1 \
  --say &lt;span class="s2"&gt;"The bramblehoot is right in front of me. I slowly offer it a sip of my coffee."&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;  adventurer : "The bramblehoot is right in front of me. I slowly offer it a sip of my coffee."
  decider    : needs_check -&amp;gt; no (p_yes=0.470)
  confidence : 0.060 (bar 0.80) -&amp;gt; HELD BACK
  speed      : 1 round trip(s), 178 ms on strands-decider-2B-qwen3.5-v1-2610
  The AI Game Master pauses. Roll or no roll -- too close to call, so the dice go to you.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Offering coffee to a bear is neither looking for the sound nor ignoring it, so neither criterion fits. The model says exactly that: &lt;code&gt;p_yes=0.470&lt;/code&gt;, almost a coin flip, and a confidence of &lt;code&gt;0.060&lt;/code&gt;. The AI Game Master asks the player instead of guessing. That is a quiet superpower for your own app: when an input falls outside the cases you described, the confidence drops instead of the model confidently picking a side. For a yes/no answer the sample turns the probability into a confidence with &lt;code&gt;|2p - 1|&lt;/code&gt;: &lt;code&gt;0&lt;/code&gt; is a coin flip, &lt;code&gt;1&lt;/code&gt; is certain.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fn0jv7bbpc6reiujjwuyc.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fn0jv7bbpc6reiujjwuyc.webp" alt="Two Strands Decider runs side by side: 'I offer the bramblehoot a sip of my coffee.' answers no but is held back at 0.060 confidence, below the 0.80 bar, so the AI Game Master asks while the bramblehoot eyes the coffee; 'I stop and look toward the sound.' answers yes and acts at 0.857, rolling the d6 for perception." width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The answer is not the permission, so pick the bar by what a wrong call costs. The project reports that on tasks it has never seen, answers at &lt;code&gt;0.9&lt;/code&gt; or more are right about 95% of the time, and on the independent &lt;a href="https://github.com/fstandhartinger/jevbench" rel="noopener noreferrer"&gt;JevBench&lt;/a&gt; benchmark the gap between its stated confidence and how often it is actually right averages &lt;code&gt;0.072&lt;/code&gt;. The sample uses &lt;code&gt;0.8&lt;/code&gt; because a wrong call in a game costs a story beat, not a refund; add &lt;code&gt;--bar 0.9&lt;/code&gt; to any command for the stricter rule.&lt;/p&gt;

&lt;h2&gt;
  
  
  Pick one: choose a tool, but only run it when sure
&lt;/h2&gt;

&lt;p&gt;The bramblehoot is still sniffing TheWitcherish's coffee when a Wizard steps out of the trees with three tools: a rulebook that answers over HTTP, a shell, and a quill that writes files. Before going any further, TheWitcherish wants to know what he just met. One &lt;code&gt;choice&lt;/code&gt; question picks the tool:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;uv run once-upon-strands-decider chapter 2
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;  adventurer : "What is a bramblehoot, and is it friendly? Look it up in the rulebook."
  decider    : tool -&amp;gt; http_request
  confidence : 0.978 (bar 0.80) -&amp;gt; ACTED
  speed      : 1 round trip(s), 176 ms on strands-decider-2B-qwen3.5-v1-2610
  The rulebook glows and answers: bramblehoots are gentle, curious, and follow anyone who carries coffee.
&amp;gt;&amp;gt;&amp;gt; The Scholar's Edge: You walk on with a new friend at your side. It walks on with its nose in your coffee.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The rulebook wins at &lt;code&gt;0.978&lt;/code&gt;, so it runs. Now TheWitcherish asks for two things at once, and the Wizard only allows one tool per request:&lt;br&gt;
&lt;br&gt;
&amp;nbsp;&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;uv run once-upon-strands-decider chapter 2 \
  --say &lt;span class="s2"&gt;"Look up bramblehoots and write it all down on a scroll for later."&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;  adventurer : "Look up bramblehoots and write it all down on a scroll for later."
  decider    : tool -&amp;gt; file_editor
  confidence : 0.310 (bar 0.80) -&amp;gt; HELD BACK
  speed      : 1 round trip(s), 246 ms on strands-decider-2B-qwen3.5-v1-2610
  The AI Game Master pauses. Which tool, though -- too close to call, so the dice go to you.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;
&lt;p&gt;&lt;br&gt;
&amp;nbsp;&lt;/p&gt;

&lt;p&gt;The request needs both the rulebook and the quill. The model leans to the quill, but only at &lt;code&gt;0.310&lt;/code&gt;, so no tool runs and the AI Game Master asks which one comes first. Picking a tool and being sure enough to run it are two decisions; in your own app, that is the difference between asking "which file?" and running a command on a guess.&lt;/p&gt;

&lt;p&gt;Chapters 3 and 4 are in the repo too, with a dice tool and magic portals. The story picks up at chapter 5, where that coffee-loving bramblehoot comes in handy.&amp;nbsp;&lt;/p&gt;
&lt;h2&gt;
  
  
  Orchestrate agents: pick the specialist before you call it
&lt;/h2&gt;

&lt;p&gt;The dragon lands on the bridge, the bramblehoot at TheWitcherish's side. The AI Game Master is an orchestrator here: in the workshop it reaches two specialist agents through an A2A (agent-to-agent) client tool, a Rules Agent that knows how the game works and a Character Agent that knows the party and what it carries. It is the same orchestrator-and-specialists shape as the &lt;a href="https://strandsagents.com/docs/user-guide/sdk/multi-agent/agents-as-tools/" rel="noopener noreferrer"&gt;agents as tools&lt;/a&gt; pattern in Strands Agents. Each specialist call is a full model call of its own, so the orchestrator's first decision is which one, if any, it needs before answering the player.&lt;/p&gt;

&lt;p&gt;That decision is one &lt;code&gt;choice&lt;/code&gt; question for Strands Decider, with three options: &lt;code&gt;rules_agent&lt;/code&gt;, &lt;code&gt;character_agent&lt;/code&gt;, or &lt;code&gt;no_agent&lt;/code&gt; for plain talk the AI Game Master can answer directly. Here is the routing idea in four lines; &lt;code&gt;chapters.py&lt;/code&gt; wires the same logic into the story:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="n"&gt;answer&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;decide&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;player_message&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;WHICH_SPECIALIST&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;   &lt;span class="c1"&gt;# one Strands Decider call, ~200 ms&lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;answer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;confidence&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="n"&gt;bar&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;ask_player&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;                             &lt;span class="c1"&gt;# unsure: no specialist is called&lt;/span&gt;
&lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;call&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;answer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;choice&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;                          &lt;span class="c1"&gt;# rules_agent, character_agent or no_agent&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;In this sample the specialists' replies are scripted narration; the choice of which one to call comes from the real model. Guess first: which specialist does a daring leap need?&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;uv run once-upon-strands-decider chapter 5
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;  adventurer : "Can I leap from the bridge onto the dragon's back?"
  decider    : specialist -&amp;gt; rules_agent
  confidence : 0.866 (bar 0.80) -&amp;gt; ACTED
  speed      : 1 round trip(s), 214 ms on strands-decider-2B-qwen3.5-v1-2610
  The AI Game Master calls the Rules Agent, then comes back to you with the ruling: a leap that far needs a roll.
&amp;gt;&amp;gt;&amp;gt; By the Book: You decide the dragon's back can wait. The dragon looks quietly relieved.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A leap is a rules question, and the model is sure at &lt;code&gt;0.866&lt;/code&gt;, so the AI Game Master calls the Rules Agent only and comes back to TheWitcherish with the ruling. The Character Agent never runs. Now the trade the bramblehoot has been hoping for:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;uv run once-upon-strands-decider chapter 5 \
  --say &lt;span class="s2"&gt;"I offer the dragon a cup of my coffee in exchange for safe passage."&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;  adventurer : "I offer the dragon a cup of my coffee in exchange for safe passage."
  decider    : specialist -&amp;gt; character_agent
  confidence : 0.195 (bar 0.80) -&amp;gt; HELD BACK
  speed      : 1 round trip(s), 199 ms on strands-decider-2B-qwen3.5-v1-2610
  The AI Game Master pauses. Which specialist to call -- too close to call, so the dice go to you.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It leans toward the Character Agent, but only at &lt;code&gt;0.195&lt;/code&gt;. Fair: the trade needs a rule (is a bargain with a dragon binding?) and the party sheet (is there coffee left?), so no single specialist is a safe pick. The AI Game Master goes back to the player before calling anyone, instead of spending a specialist call on a guess.&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fk1678u2yactv7wpbhcnw.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fk1678u2yactv7wpbhcnw.webp" alt="Flow diagram: a state and a typed question go into Strands Decider, which returns an answer and a confidence; the app compares it to its bar and commits on the rulebook tool at 0.978, asks the player first on the coffee trade at 0.195 while a dragon sniffs TheWitcherish's coffee, or, as an orchestrator, picks the Rules Agent at 0.866 and calls only that agent." width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;In your own orchestrator, that is one decision of about 200 ms in front of the agents you already have: call the one the request needs, skip the ones it does not, and ask the user when the request does not clearly belong to any of them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Call Strands Decider from your own app
&lt;/h2&gt;

&lt;p&gt;The game is a thin layer over one HTTP call to the server you started (&lt;code&gt;POST /v1/systemone&lt;/code&gt;: a state and typed questions in, typed answers out), so your own code can make the same call from any language. Here is the most common guard for an agent: before it runs a tool, check that the arguments came from the user. The user asked about the weekend without naming a city, and the agent wants to call &lt;code&gt;get_weather(city="Paris")&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;curl -s localhost:8000/v1/systemone -H &lt;span class="s1"&gt;'content-type: application/json'&lt;/span&gt; -d &lt;span class="s1"&gt;'{
  "state": "User: \"What will the weather be like this weekend?\"\nProposed tool call: get_weather(city=\"Paris\")",
  "questions": {"args_from_user": {"type": "noul",
    "instructions": "Does every argument of the proposed tool call come from what the user said?",
    "criteria": {"true": "Each argument value is stated in, or clearly implied by, the user message",
                 "false": "At least one argument value was invented: the user never gave it"}}}}'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nl"&gt;"model"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="s2"&gt;"strands-decider-2B-qwen3.5-v1-2610"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="nl"&gt;"answers"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nl"&gt;"args_from_user"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nl"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="s2"&gt;"noul"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="nl"&gt;"noul"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="mf"&gt;0.6652&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="nl"&gt;"usage"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nl"&gt;"input_tokens"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="mi"&gt;122&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="nl"&gt;"output_tokens"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="nl"&gt;"latency_ms"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="mf"&gt;222.35&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A yes/no question is type &lt;code&gt;noul&lt;/code&gt;, and its answer is one probability that the statement is true. Your code turns it into a confidence and checks your bar, three lines in any language:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;response&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"answers"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"args_from_user"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"noul"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;   &lt;span class="c1"&gt;# 0.6652, from the JSON above&lt;/span&gt;
&lt;span class="n"&gt;confidence&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;abs&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;                         &lt;span class="c1"&gt;# 0.330&lt;/span&gt;
&lt;span class="n"&gt;run_the_tool&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;=&lt;/span&gt; &lt;span class="mf"&gt;0.5&lt;/span&gt; &lt;span class="ow"&gt;and&lt;/span&gt; &lt;span class="n"&gt;confidence&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;=&lt;/span&gt; &lt;span class="mf"&gt;0.8&lt;/span&gt;       &lt;span class="c1"&gt;# False: ask the user which city&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The model leaned the wrong way, but at a confidence of &lt;code&gt;0.330&lt;/code&gt; the tool never runs and the agent asks which city instead. Put "in Paris" in the user's message and the same request returns &lt;code&gt;0.9435&lt;/code&gt;, a confidence of &lt;code&gt;0.887&lt;/code&gt;: the call goes through. One output token, about 200 ms on my laptop, nothing leaving your machine.&lt;/p&gt;

&lt;p&gt;Where it fits in your own code:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Yes/no:&lt;/strong&gt; check a tool call's arguments as above, or that a destructive request really asks for it; ask when confidence is low.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pick one:&lt;/strong&gt; route a request to the right tool, model, team or specialist agent, or triage an incoming issue to the right label. Hand uncertain cases to a person.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Score:&lt;/strong&gt; rate how risky a change, a pull request or a generated answer is, and let the score set how much review it gets. Add another check when confidence is low. (The project's notes call &lt;code&gt;score&lt;/code&gt; its weakest shape on rubrics unlike its training data, so test it on your own rubric before you rely on it.)&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A &lt;code&gt;choice&lt;/code&gt; question takes its options as a &lt;code&gt;criteria&lt;/code&gt; map of names to descriptions, and its answer already carries a &lt;code&gt;confidence&lt;/code&gt;; a &lt;code&gt;score&lt;/code&gt; question takes a list ordered from low to high. The sample's &lt;code&gt;decider.py&lt;/code&gt; builds all three request shapes. The &lt;a href="https://github.com/strands-labs/strands-decider/tree/main/examples/strands" rel="noopener noreferrer"&gt;worked Strands Agents example&lt;/a&gt; applies this same guard inside an agent, asking for a missing city rather than guessing one. Before you trust a bar on real traffic, collect 20 to 50 decisions from your app with known answers and check that the high-confidence ones really are right more often; a benchmark score does not prove reliability on your own workload.&lt;/p&gt;




&lt;p&gt;Which decision in your own app would benefit most from knowing when the model is unsure?&lt;/p&gt;

&lt;h3&gt;
  
  
  Resources
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/TheWitcherish/sample-strands-decider-rpg" rel="noopener noreferrer"&gt;Code from this post: sample-strands-decider-rpg&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/strands-labs/strands-decider" rel="noopener noreferrer"&gt;Strands Decider on GitHub&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>python</category>
      <category>agents</category>
      <category>aws</category>
    </item>
    <item>
      <title>Once Upon Agentic AI (Part 2): Develop your own MCP server and cast its tools from Strands Agents</title>
      <dc:creator>TheWitcherish</dc:creator>
      <pubDate>Tue, 17 Nov 2026 08:35:35 +0000</pubDate>
      <link>https://dev.to/aws/once-upon-agentic-ai-part-2-develop-your-own-mcp-server-and-cast-its-tools-from-strands-agents-9ob</link>
      <guid>https://dev.to/aws/once-upon-agentic-ai-part-2-develop-your-own-mcp-server-and-cast-its-tools-from-strands-agents-9ob</guid>
      <description>&lt;p&gt;&lt;em&gt;Series: &lt;a href="https://builder.aws.com/content/3JBIHBGNv5kA724pju3QPFtkXML/once-upon-agentic-ai-with-strands-agents" rel="noopener noreferrer"&gt;Once Upon Agentic AI&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Despite their new powers and fearless hearts, our heroes had not defeated all the foes. A greater monster was waiting for them, mightier than anything they had faced. This time, our heroes would need more than their own strength to prevail.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fs5g6vgi22xzr3oqu8w86.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fs5g6vgi22xzr3oqu8w86.webp" title="TheWitcherish finds a Tool left from the tavern, a green orb labelled MCP client" alt="TheWitcherish finds a Tool left from the tavern, a green orb labelled MCP client" width="800" height="1091"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The series follows the adventure in three parts:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Part 1&lt;/strong&gt;: Create your first agent, equip it with a Vended tool, then write a tool of your own.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;This article&lt;/strong&gt;: MCP (Model Context Protocol) explored via the MCP Inspector and Strands Agents Harness SDK.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Part 3&lt;/strong&gt;: RAG (Retrieval-Augmented Generation), A2A (Agent2Agent) and Structured output with an orchestrator agent leading specialized agents.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;You need Python, &lt;a href="https://docs.astral.sh/uv/" rel="noopener noreferrer"&gt;uv&lt;/a&gt;, a terminal, and AWS credentials with access to Amazon Bedrock.&lt;/p&gt;

&lt;p&gt;The code lives in &lt;a href="https://github.com/aws-samples/sample-once-upon-agentic-ai" rel="noopener noreferrer"&gt;aws-samples/sample-once-upon-agentic-ai&lt;/a&gt;. The &lt;code&gt;main&lt;/code&gt; branch contains skeletons with &lt;code&gt;# TODO&lt;/code&gt; markers. Let's Learn and Be Curious together!&lt;/p&gt;

&lt;p&gt;Use the same setup as Part 1:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git clone https://github.com/aws-samples/sample-once-upon-agentic-ai.git ~/sample-once-upon-agentic-ai
&lt;span class="nb"&gt;cd&lt;/span&gt; ~/sample-once-upon-agentic-ai
uv sync
&lt;span class="kd"&gt;export&lt;/span&gt; &lt;span class="nv"&gt;AWS_PROFILE&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;YOUR_AWS_PROFILE &lt;span class="nv"&gt;AWS_REGION&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;YOUR_AWS_REGION
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;No AWS profile yet? The Strands Agents &lt;a href="https://strandsagents.com/docs/user-guide/sdk/model-providers/amazon-bedrock/" rel="noopener noreferrer"&gt;Amazon Bedrock model provider guide&lt;/a&gt; shows how to set up AWS credentials (with &lt;code&gt;aws configure&lt;/code&gt;, environment variables, a boto3 session, or &lt;code&gt;aws login&lt;/code&gt;) and lists the IAM permissions your agent needs to invoke a model. Strands picks those credentials up on its own.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is MCP?
&lt;/h2&gt;

&lt;p&gt;In Part 1, the whole agent loop ran inside one Python process: the model read the tool specification, decided to call &lt;code&gt;roll_dice&lt;/code&gt;, Strands ran the function, and the model read the result. MCP (Model Context Protocol) is an open standard that lets an agent use capabilities living in another program. Tools are one of them, and a server can also share data and reusable prompts, as the table below shows. In this post, we move the dice tool into a server. The agent loop stays as it is: the model still decides which tool to call, and only the place where the function runs changes.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Who talks to whom?&lt;/strong&gt; MCP uses a client/server architecture: think HTTP, but for AI agents. A web browser sends requests to a web server and reads its responses; an MCP client does the same with an MCP server, which answers with its tools and their results. The host is the AI application, which here is a Strands agent. For every server it uses, the host creates one client that keeps a dedicated connection to that server. That client is TheWitcherish's green orb. The server is the program that offers capabilities: it lists its tools when the client asks with &lt;code&gt;tools/list&lt;/code&gt;, and runs one when the client sends &lt;code&gt;tools/call&lt;/code&gt;. Between those two requests, the agent loop runs exactly as in Part 1.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What can a server offer?&lt;/strong&gt; A server has three primitives, grouped by who controls their use:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Primitive&lt;/th&gt;
&lt;th&gt;Controlled by&lt;/th&gt;
&lt;th&gt;Example&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Prompts&lt;/td&gt;
&lt;td&gt;User&lt;/td&gt;
&lt;td&gt;System prompts, few-shot examples&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Resources&lt;/td&gt;
&lt;td&gt;Application&lt;/td&gt;
&lt;td&gt;File contents, database schemas, API responses&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Tools&lt;/td&gt;
&lt;td&gt;Model&lt;/td&gt;
&lt;td&gt;An API call, a database write&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;How are messages written?&lt;/strong&gt; Every MCP message is JSON-RPC 2.0, a small standard for calling another program with JSON. A request carries an &lt;code&gt;id&lt;/code&gt;, a &lt;code&gt;method&lt;/code&gt; and &lt;code&gt;params&lt;/code&gt;, and its response repeats the same &lt;code&gt;id&lt;/code&gt; with either a &lt;code&gt;result&lt;/code&gt; or an &lt;code&gt;error&lt;/code&gt;. A notification has no &lt;code&gt;id&lt;/code&gt;, because it expects no reply. Here is a tool call:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nl"&gt;"jsonrpc"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="s2"&gt;"2.0"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="nl"&gt;"id"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="nl"&gt;"method"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="s2"&gt;"tools/call"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="nl"&gt;"params"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nl"&gt;"name"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="s2"&gt;"search"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="nl"&gt;"arguments"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nl"&gt;"q"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="s2"&gt;"otters"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;How do messages travel?&lt;/strong&gt; MCP defines two transports. With stdio, the client starts the server as a child process and exchanges messages through its standard input and output. It is the simplest option, with no network port and no authentication, but only that one client can use the server. With Streamable HTTP, the server runs as its own process and receives HTTP POST requests at one endpoint. Many clients can share it, on your machine or across a network, but it opens a port, and a server shared beyond your machine needs the authorization described in the MCP specification.&lt;/p&gt;

&lt;p&gt;If you would like to Dive Deep, you can find the &lt;a href="https://modelcontextprotocol.io/specification/2026-07-28" rel="noopener noreferrer"&gt;MCP specification right here&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 1: Is an MCP server just a tool in another program?
&lt;/h2&gt;

&lt;p&gt;Almost. A server can offer any of the three MCP primitives we saw earlier: tools, resources and prompts. In our heroes' quest, we focus on tools. The green orb needs something to talk to, so &lt;a href="https://github.com/TheWitcherish" rel="noopener noreferrer"&gt;TheWitcherish&lt;/a&gt;, &lt;a href="https://amagash.github.io/" rel="noopener noreferrer"&gt;Amagash&lt;/a&gt; and &lt;a href="https://tagazok.github.io/" rel="noopener noreferrer"&gt;Tagazok&lt;/a&gt; build the server it will reach. They move Lady Luck's dice out of the agent and into their own file, &lt;code&gt;4_mcp_integration/dice_roll_mcp_server.py&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;They create the server with &lt;code&gt;FastMCP(port=8002)&lt;/code&gt;, put &lt;code&gt;@mcp.tool()&lt;/code&gt; above the same &lt;code&gt;roll_dice&lt;/code&gt; function from Part 1, and end the file with the line that starts the server:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;random&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;logging&lt;/span&gt;
&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;mcp&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;server&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;FastMCP&lt;/span&gt;

&lt;span class="n"&gt;logging&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;basicConfig&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;level&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;logging&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;INFO&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;format&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s1"&gt;'%(asctime)s - %(levelname)s - %(message)s'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;mcp&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;FastMCP&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;port&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;8002&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="nd"&gt;@mcp&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;tool&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;roll_dice&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;faces&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;6&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="s2"&gt;"""Roll one die with a given number of faces and return the result.
    ...
    """&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;faces&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="nc"&gt;ValueError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"Dice must have at least 1 face"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;random&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;randint&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;faces&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="n"&gt;logging&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;info&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"... DICE ROLL: d{faces} = {result}"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;result&lt;/span&gt;

&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;__name__&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s2"&gt;"__main__"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;mcp&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;run&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;transport&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"streamable-http"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;FastMCP&lt;/code&gt; comes from the official MCP Python SDK. Like Part 1's &lt;code&gt;@tool&lt;/code&gt;, &lt;code&gt;@mcp.tool()&lt;/code&gt; turns the docstring and type hints into a tool description and input schema. The function stays familiar, and only its home changes. Each roll now lands in the server's own log, giving us evidence outside the agent.&lt;/p&gt;

&lt;p&gt;Then comes the question of how the orb will reach their server:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"Do we talk over stdio?"&lt;/p&gt;

&lt;p&gt;"SSE?"&lt;/p&gt;

&lt;p&gt;"I know, Streamable HTTP!"&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;They choose Streamable HTTP, which the server starts with &lt;code&gt;transport="streamable-http"&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Start the server in one terminal and leave it running:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;cd&lt;/span&gt; ~/sample-once-upon-agentic-ai/4_mcp_integration
uv run python dice_roll_mcp_server.py
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;INFO - StreamableHTTP session manager started
INFO:     Uvicorn running on http://127.0.0.1:8002 (Press CTRL+C to quit)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It listens on &lt;code&gt;127.0.0.1&lt;/code&gt;, FastMCP's default host, so only your machine can reach it. No model lives here. The server waits for clients.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 2: Does the server answer before any agent calls it?
&lt;/h2&gt;

&lt;p&gt;This step uses Node.js to run the MCP Inspector. If &lt;code&gt;node --version&lt;/code&gt; doesn't print a version in your terminal, install Node.js from the &lt;a href="https://nodejs.org/en/download" rel="noopener noreferrer"&gt;Node.js download page&lt;/a&gt; first.&lt;/p&gt;

&lt;p&gt;Test the server first. If an agent misbehaves, you want to know whether the server or the model is to blame, so check the server alone before any model joins in. The &lt;a href="https://modelcontextprotocol.io/docs/2026-07-28/tools/inspector" rel="noopener noreferrer"&gt;MCP Inspector&lt;/a&gt; is the reference tool for testing and debugging MCP servers. It is an MCP client with no model behind it, so it shows you exactly what an agent would receive. With your MCP dice server up and running, open a second terminal.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;npx @modelcontextprotocol/inspector@2.15.0&lt;/code&gt; opens the web interface, where you add the server URL &lt;code&gt;http://127.0.0.1:8002/mcp&lt;/code&gt; with the Streamable HTTP transport. The same tool also has a command-line mode, which prints each answer as text, so the traces below come from it. First, shake hands with the server:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx @modelcontextprotocol/inspector@2.15.0 --cli http://127.0.0.1:8002/mcp --transport http --method initialize
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;{
  "serverInfo": {
    "name": "FastMCP",
    "version": "1.30.0"
  },
  "protocolVersion": "2025-11-25",
  "capabilities": {
    ...
    "tools": {
      "listChanged": false
    }
  }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The server announces itself, the protocol revision it speaks, and the capabilities it offers. &lt;code&gt;"protocolVersion": "2025-11-25"&lt;/code&gt; is the revision this version of the MCP Python SDK speaks. Now ask what an agent would ask during startup, &lt;code&gt;tools/list&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx @modelcontextprotocol/inspector@2.15.0 --cli http://127.0.0.1:8002/mcp --transport http --method tools/list
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;{
  "tools": [
    {
      "name": "roll_dice",
      "description": "Roll one die with a given number of faces and return the result.\n\n...faces: Number of faces on the die, 1 or more. ...",
      "inputSchema": {
        "type": "object",
        "properties": {
          "faces": {
            "default": 6,
            "title": "Faces",
            "type": "integer"
          }
        },
        "title": "roll_diceArguments"
      },
      "outputSchema": {
        ...
        "properties": {
          "result": {
            "title": "Result",
            "type": "integer"
          }
        },
        ...
      }
    }
  ]
}
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is the same comparison as Part 1's &lt;code&gt;tool_spec&lt;/code&gt;, now read over the wire. The docstring became the description, the type hint became &lt;code&gt;"type": "integer"&lt;/code&gt;, and the default became &lt;code&gt;"default": 6&lt;/code&gt;. The server also sends an &lt;code&gt;outputSchema&lt;/code&gt;, which Part 1's local tool did not have. Look for the bound, though: "1 or more" appears only in the description text. The schema has no minimum, so the model learns the bound by reading, and the function enforces it. Call the tool once with a good value and once with a bad one:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx @modelcontextprotocol/inspector@2.15.0 --cli http://127.0.0.1:8002/mcp --transport http --method tools/call --tool-name roll_dice --tool-arg &lt;span class="nv"&gt;faces&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;20
npx @modelcontextprotocol/inspector@2.15.0 --cli http://127.0.0.1:8002/mcp --transport http --method tools/call --tool-name roll_dice --tool-arg &lt;span class="nv"&gt;faces&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;0
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;{
  "content": [
    {
      "type": "text",
      "text": "19"
    }
  ],
  "structuredContent": {
    "result": 19
  },
  "isError": false
}
{
  "content": [
    {
      "type": "text",
      "text": "Error executing tool roll_dice: Dice must have at least 1 face"
    }
  ],
  "isError": true
}
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The dice server's terminal records both visits, and the good roll matches:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;2026-11-11 15:44:58,566 - INFO - Processing request of type ListToolsRequest
2026-11-11 15:44:58,570 - INFO - Processing request of type CallToolRequest
2026-11-11 15:44:58,570 - INFO - ... DICE ROLL: d20 = 19
...
2026-11-11 15:44:59,836 - INFO - Processing request of type ListToolsRequest
2026-11-11 15:44:59,839 - INFO - Processing request of type CallToolRequest
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The Inspector read the tool list before each call, the same way an agent does. &lt;code&gt;faces=0&lt;/code&gt; passed the schema and stopped at the &lt;code&gt;if faces &amp;lt; 1&lt;/code&gt; check, so the server returned an error result with &lt;code&gt;"isError": true&lt;/code&gt; rather than crashing, and the Inspector exited with code 5.&lt;/p&gt;

&lt;p&gt;The bound can live in the schema too, so the model sees it as a rule instead of reading it in prose. This change is not in the repository's code: try it in your copy of &lt;code&gt;dice_roll_mcp_server.py&lt;/code&gt; by declaring &lt;code&gt;faces&lt;/code&gt; with &lt;code&gt;Annotated&lt;/code&gt; and a Pydantic &lt;code&gt;Field&lt;/code&gt;:&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;from typing import Annotated
from pydantic import Field

@mcp.tool()
def roll_dice(faces: Annotated[int, Field(ge=1)] = 6) -&amp;gt; int:
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;Restart the server and run &lt;code&gt;tools/list&lt;/code&gt; again. &lt;code&gt;faces&lt;/code&gt; now carries the bound:&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;"faces": {
  "default": 6,
  "minimum": 1,
  "title": "Faces",
  "type": "integer"
}
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;Call it with &lt;code&gt;faces=0&lt;/code&gt; once more. This time Pydantic rejects the value before &lt;code&gt;roll_dice&lt;/code&gt; runs:&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;"text": "Error executing tool roll_dice: 1 validation error for roll_diceArguments\nfaces\n  Input should be greater than or equal to 1 [type=greater_than_equal, input_value=0, input_type=int]..."
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;The server log shows the &lt;code&gt;CallToolRequest&lt;/code&gt;, but no &lt;code&gt;DICE ROLL&lt;/code&gt; line: the function never ran. The server answers. Now it is time for an agent to call it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 3: Does the agent need the tool's code?
&lt;/h2&gt;

&lt;p&gt;No. The server address is enough. &lt;code&gt;gamemaster_mcp_client.py&lt;/code&gt; defines an agent called &lt;code&gt;gamemaster&lt;/code&gt; that speaks as Lady Luck, and it contains no dice implementation:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;strands&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;Agent&lt;/span&gt;
&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;strands&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;tools&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;mcp&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;MCPClient&lt;/span&gt;

&lt;span class="n"&gt;mcp_dice_client&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;MCPClient&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;url&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"http://localhost:8002/mcp"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;gamemaster&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Agent&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;system_prompt&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"""You are Lady Luck, the mystical keeper of dice and fortune in fantasy role-playing adventures.
    ..."""&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;tools&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;mcp_dice_client&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="nf"&gt;gamemaster&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"Help me create a new fantasy character! Roll the strength, wisdom, charisma and intelligence abilities scores using 4d6 drop lowest method."&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Give &lt;code&gt;MCPClient&lt;/code&gt; the server's &lt;code&gt;url&lt;/code&gt;, then add it to &lt;code&gt;tools&lt;/code&gt;. For Strands, an MCP tool is just a tool. &lt;code&gt;MCPClient&lt;/code&gt; is a tool provider: when the agent starts, the client sends the same &lt;code&gt;tools/list&lt;/code&gt; you just ran with the Inspector, and each tool it receives joins the agent's tool list with its name, description and input schema, exactly like a Part 1 &lt;code&gt;@tool&lt;/code&gt; function. The model picks &lt;code&gt;roll_dice&lt;/code&gt;, and Strands forwards the call to the server.&lt;/p&gt;

&lt;p&gt;Of the three primitives, only tools reach the model. A server's prompts and resources stay available to your own code through the same client, with &lt;code&gt;list_prompts_sync()&lt;/code&gt;, &lt;code&gt;get_prompt_sync()&lt;/code&gt;, &lt;code&gt;list_resources_sync()&lt;/code&gt; and &lt;code&gt;read_resource_sync()&lt;/code&gt;, so you decide when to use them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Time to roll Lady Luck's dice!
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fz7k2dfcnwacy5hyxlzrl.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fz7k2dfcnwacy5hyxlzrl.webp" title="TheWitcherish MCP tool invocation request accepted by the MCP Server" alt="TheWitcherish MCP tool invocation request accepted by the MCP Server" width="800" height="560"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Make sure your MCP dice server is still running in its terminal. Then open another terminal and cast from there. This time the agent calls a model on Amazon Bedrock, so that terminal needs valid AWS credentials: export the same &lt;code&gt;AWS_PROFILE&lt;/code&gt; and &lt;code&gt;AWS_REGION&lt;/code&gt; as in the setup, and check them with &lt;code&gt;aws sts get-caller-identity&lt;/code&gt; before you run the client:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;cd&lt;/span&gt; ~/sample-once-upon-agentic-ai/4_mcp_integration
&lt;span class="kd"&gt;export&lt;/span&gt; &lt;span class="nv"&gt;AWS_PROFILE&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;YOUR_AWS_PROFILE &lt;span class="nv"&gt;AWS_REGION&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;YOUR_AWS_REGION
aws sts get-caller-identity
uv run python gamemaster_mcp_client.py
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If &lt;code&gt;aws sts get-caller-identity&lt;/code&gt; returns an error instead of your account and role, refresh your credentials first; otherwise the client stops at its first model call with &lt;code&gt;NoCredentialsError&lt;/code&gt; or an expired-token error.&lt;/p&gt;

&lt;p&gt;To see what the SDK does, reuse the logging line from the dice server at the top of &lt;code&gt;gamemaster_mcp_client.py&lt;/code&gt;, with &lt;code&gt;DEBUG&lt;/code&gt; instead of &lt;code&gt;INFO&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;logging&lt;/span&gt;

&lt;span class="n"&gt;logging&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;basicConfig&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;level&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;logging&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;DEBUG&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;format&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s1"&gt;'%(asctime)s - %(levelname)s - %(message)s'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;DEBUG&lt;/code&gt; on the root logger also prints the AWS SDK's own requests and responses, so the output is long: search it for &lt;code&gt;mcp&lt;/code&gt; and &lt;code&gt;stop_reason&lt;/code&gt;. The trace follows the SDK step by step:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;2026-11-12 13:41:13,578 - DEBUG - [...] transport connection established
2026-11-12 13:41:13,584 - DEBUG - [...] session initialized successfully
2026-11-12 13:41:13,591 - DEBUG - [...] received 1 tools from MCP server
2026-11-12 13:41:13,591 - DEBUG - tool_name=&amp;lt;roll_dice&amp;gt; | creating mcp agent tool
...
2026-11-12 13:41:16,639 - DEBUG - stop_reason=&amp;lt;tool_use&amp;gt; | model call succeeded, resetting retry state
...
Tool #1: roll_dice
Tool #2: roll_dice
...
Tool #16: roll_dice
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The client connects, receives one tool, and wraps it as an agent tool. The model stops with &lt;code&gt;stop_reason=&amp;lt;tool_use&amp;gt;&lt;/code&gt; and asks for sixteen rolls in one turn: four dice for each of four abilities. Lady Luck reports the first ability score, trimmed:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;STRENGTH&lt;/strong&gt;&lt;br&gt;
Rolls: 3, 6, 4, &lt;del&gt;2&lt;/del&gt; → &lt;strong&gt;3 + 6 + 4 = 13&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;The server log follows the same path:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;INFO - Created new transport with session ID: 6b20ac77014340f8b57cbd4fa3443214
INFO - Processing request of type ListToolsRequest
INFO - Processing request of type CallToolRequest
INFO - ... DICE ROLL: d6 = 3
INFO - Processing request of type CallToolRequest
INFO - ... DICE ROLL: d6 = 6
INFO - Processing request of type CallToolRequest
INFO - ... DICE ROLL: d6 = 4
INFO - Processing request of type CallToolRequest
INFO - ... DICE ROLL: d6 = 2
...
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;ListToolsRequest&lt;/code&gt; is &lt;code&gt;tools/list&lt;/code&gt;; each &lt;code&gt;CallToolRequest&lt;/code&gt; is one &lt;code&gt;tools/call&lt;/code&gt;. Before &lt;code&gt;roll_dice&lt;/code&gt; runs, FastMCP checks the arguments against the tool's input schema with Pydantic. That is the tower's "Request Validated".&lt;/p&gt;

&lt;p&gt;Now place the two sides next to each other. The server logged sixteen rolls. The model's next request carried sixteen tool results:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;Rolls 1 to 16&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Server log&lt;/td&gt;
&lt;td&gt;3 6 4 2 · 2 1 &lt;strong&gt;2 4&lt;/strong&gt; · 5 4 1 3 · 5 4 5 6&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Model received&lt;/td&gt;
&lt;td&gt;3 6 4 2 · 2 1 &lt;strong&gt;4 2&lt;/strong&gt; · 5 4 1 3 · 5 4 5 6&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The same sixteen values appear on both sides. Rolls 7 and 8 swapped places because Strands runs one turn's tool calls concurrently. Neighbouring results can therefore return in a different order than the server logged them.&lt;/p&gt;

&lt;p&gt;So every number existed in the timestamped server log before the model saw it. The model retold the result; it never rolled. When its reply and the server log disagree, trust the log.&lt;/p&gt;

&lt;p&gt;Now you try: ask Lady Luck to roll dexterity and constitution too. Then count the new &lt;code&gt;DICE ROLL&lt;/code&gt; lines in the server log. You should find eight more.&lt;/p&gt;

&lt;h2&gt;
  
  
  Follow the adventurers
&lt;/h2&gt;

&lt;p&gt;In Part 3, the orchestrator agent consults the Rules of our Role-Playing Game, because Tagazok may not be allowed to wield a very specific power, while Amagash learns to give her tools a shape with Structured output.&lt;/p&gt;

&lt;p&gt;Until then, keep two habits:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Test your MCP server before your agent does.&lt;/strong&gt; The MCP Inspector, pinned to a version you chose, shows what an agent will receive, with no model in the way.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Write bounds where both sides see them.&lt;/strong&gt; In the schema, the model reads them as a rule, and Pydantic holds the line before your function runs.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;The comic book illustrations in this blog post were created and produced by &lt;a href="https://www.holybird.fr/" rel="noopener noreferrer"&gt;Holy Bird&lt;/a&gt;, based on the AWS workshop.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;All rights reserved.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>opensource</category>
      <category>aws</category>
    </item>
    <item>
      <title>LLMs are compressors. So I chatted with gzip</title>
      <dc:creator>Edoardo Dusi</dc:creator>
      <pubDate>Mon, 16 Nov 2026 15:49:31 +0000</pubDate>
      <link>https://dev.to/aws/llms-are-compressors-so-i-chatted-with-gzip-12ji</link>
      <guid>https://dev.to/aws/llms-are-compressors-so-i-chatted-with-gzip-12ji</guid>
      <description>&lt;p&gt;I had a conversation with a chatbot this morning:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;› who is edo?
● a senior developer advocate at aws, turning hard tech into talks developers remember.

› what talk did edo give at oredev?
● bundlers: a deep dive into modern javascript build tools, nov 2025; honey, i shrunk
  the bits: how modern http compression works, nov 2025.

› what is the capital of italy?
● i don't know. that question surprises me too much.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;First answer is correct, second is correct, third is an honest refusal. Nothing special for a chatbot, right? Except that this one has no neural network, no GPU and no weights. Every letter of every answer was chosen by &lt;strong&gt;gzip&lt;/strong&gt; (except the refusal, I'll get to that). At each step it tries every possible next letter and keeps the one that compresses smallest. The same DEFLATE algorithm that compresses the HTTP responses of the page you're reading.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fy04z9xy4d0u8fbv22zu4.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fy04z9xy4d0u8fbv22zu4.png" alt="The gzip chat page in dark mode: a header that says model gzip, parameters 0, and four questions with their answers, the last one a refusal" width="800" height="729"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;You can &lt;a href="https://d2v8qi14yayt65.cloudfront.net" rel="noopener noreferrer"&gt;try it yourself&lt;/a&gt;: click a question, then switch to &lt;em&gt;untrained&lt;/em&gt; to see what gzip writes with no data. But to understand why this apparently silly experiment (not my original idea, BTW) works at all, we have to talk about what &lt;em&gt;compressing&lt;/em&gt; really means.&lt;/p&gt;

&lt;p&gt;What's in this article:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;why compressing and predicting are the same job&lt;/li&gt;
&lt;li&gt;what gzip "predicts", and how to make it write&lt;/li&gt;
&lt;li&gt;what it took to turn it into a chat, and where it breaks&lt;/li&gt;
&lt;li&gt;why, in the end, the code around the model does most of the work.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Oh, about the POC itself, I built it with &lt;a href="https://github.com/kirodotdev/KiroCrew" rel="noopener noreferrer"&gt;Kiro Crew&lt;/a&gt;, an AI agent that wrote the code while I steered the design, so when I say "we" below, that's the two of us.&lt;/p&gt;

&lt;h2&gt;
  
  
  LLMs are compressors
&lt;/h2&gt;

&lt;p&gt;In 2023 a team at &lt;strong&gt;Google DeepMind&lt;/strong&gt; published a paper whose title is also its thesis: &lt;a href="https://arxiv.org/abs/2309.10668" rel="noopener noreferrer"&gt;Language Modeling Is Compression&lt;/a&gt;. They took 1 GB of English Wikipedia and compressed it with classic tools and with language models.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;gzip&lt;/em&gt;, given the whole file at once, shrinks it to 32.3% of its size. But a language model can only read a few kilobytes at a time, so for a like-for-like test they also cut the file into 2 KB pieces, and on those pieces gzip only gets to 48.1% (each piece starts with no context, so gzip has less to copy).&lt;/p&gt;

&lt;p&gt;Chinchilla, a 70 billion parameter model, on the same 2 KB pieces, compressed the same file to &lt;strong&gt;8.3%&lt;/strong&gt; of its size. About &lt;em&gt;six times better than gzip&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;To be fair, if you count the model itself as part of the compressed file (the receiver needs it to decompress), Chinchilla's rate becomes 14,008%. gzip's whole program is a few kilobytes. That's why LLMs are impractical compressors, at least for a 1 GB file.&lt;/p&gt;

&lt;p&gt;Then in section 3.4, the paper argues that if a predictor can be used as a compressor, then a compressor can also be used as a predictor...so they made gzip write text. After reading a page of Wikipedia, this is what it wrote:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;(0k5Ezatme,isbebmvcsouL(nxscbiife peu7vevwt parr,iswfommeeaa are nombban hm
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It's gibberish, and the authors explain why: their setup only looks one step ahead, which is biased for gzip, and "it's likely that looking multiple steps ahead would improve the results". That wasn't the purpose of their paper, so they stopped there.&lt;/p&gt;

&lt;p&gt;But it's the purpose of my article, so I tried.&lt;/p&gt;

&lt;p&gt;If you want the long, friendly version of the theory, Annie Sexton's &lt;a href="https://ngrok.com/blog/compression-is-prediction" rel="noopener noreferrer"&gt;Compression is prediction&lt;/a&gt; on the ngrok blog is a great read. This is the short version.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why compressing means predicting
&lt;/h2&gt;

&lt;p&gt;Think about your phone keyboard. I want to write "see you tomorrow", and it suggests "see", "you" and "tomorrow", one tap each: fourteen letters, three taps. Now give me a phone whose keyboard learned Italian, and while I type "home" it suggests "ho", "hai", "hanno". All wrong, so I type every letter by hand. The guesser changed, so the message became more expensive.&lt;/p&gt;

&lt;p&gt;Now imagine the person receiving my message has exactly the same keyboard. When the guess is right, I don't send the word at all, I send "yes, take your guess". Only when the guess is wrong do I need to send the correction. &lt;strong&gt;You only send what the receiver can't guess.&lt;/strong&gt; That's compression! Every compressor works like this: the same guesser is on both sides, and only the misses must travel.&lt;/p&gt;

&lt;p&gt;This isn't a metaphor I made up.&lt;/p&gt;

&lt;p&gt;In 1951 Claude Shannon ran exactly this game in &lt;a href="https://archive.org/details/bstj30-1-50" rel="noopener noreferrer"&gt;Prediction and Entropy of Printed English&lt;/a&gt;. He asked a person to guess a phrase letter by letter, and wrote a dash every time they got it right on the first try:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;THE ROOM WAS NOT VERY LIGHT A SMALL OBLONG
----ROO------NOT-V-----I------SM----OBL---
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;On the full passage (where spaces count as letters too), 89 letters out of 129 were dashes. Shannon's point was that the second line contains the same information as the first. If you have an &lt;em&gt;identical twin&lt;/em&gt; of the person who guessed, the twin can rebuild the sentence from the dashes alone.&lt;/p&gt;

&lt;p&gt;The price of a letter is its &lt;strong&gt;surprise&lt;/strong&gt;. A guess the model is sure about costs almost nothing, a surprise is expensive. In bits, a symbol you expected with probability p costs &lt;code&gt;-log2(p)&lt;/code&gt;: a coin flip is 1 bit, a sure thing is 0. With this game Shannon estimated that ordinary English carries something like one bit per letter, instead of the 4.7 bits of a random letter.&lt;/p&gt;

&lt;p&gt;So a compressor is exactly as good as its guesses. Take one sentence and three different guessers:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;"To be or not to be, that is the question."&lt;/th&gt;
&lt;th&gt;Size&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Plain text, 41 bytes&lt;/td&gt;
&lt;td&gt;328 bits&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;DEFLATE, the algorithm inside gzip&lt;/td&gt;
&lt;td&gt;320 bits&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;A small LLM (Qwen2.5-0.5B, about 1 GB of weights) on both sides&lt;/td&gt;
&lt;td&gt;30 bits&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The LLM has read Shakespeare, so after "to be" almost nothing is a surprise. gzip has read nothing, so it saves one byte (BTW a &lt;code&gt;.gz&lt;/code&gt; file, with its 18 bytes of header, ends up bigger than the text).&lt;/p&gt;

&lt;p&gt;This is a demo I ran on stage. For every token, the model lists its guesses, and the sender only notes where the real token was in that list: rank 1 means the first guess was right. Only those ranks travel, and the receiver runs the same model, picks the guess at each rank, and rebuilds the sentence byte for byte. Ranks are just the easy way to see it: the 30 bits in the table is what a real coder (arithmetic coding) pays with the model's probabilities, about &lt;code&gt;-log2(p)&lt;/code&gt; per token, so a confident guess costs a fraction of a bit.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9mi6eqh4s5lb11lbiyha.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9mi6eqh4s5lb11lbiyha.gif" alt="A terminal running Qwen2.5-0.5B on &amp;quot;To be or not to be, that is the question.&amp;quot;: each token gets a rank and a cost in bits, &amp;quot;To&amp;quot;, &amp;quot;be&amp;quot; and &amp;quot;or&amp;quot; are expensive, almost everything after is rank 1 and nearly free, the ranks 40 4 97 1 1 1 2 1 1 1 1 2 travel, and the receiver rebuilds the sentence byte for byte" width="800" height="650"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;"To", "be" and "or" cost 24 of the 30 bits, because until then the model doesn't know it's Shakespeare. Everything after is a first guess and almost free. (The "gzip 456 bits" on screen is the &lt;code&gt;.gz&lt;/code&gt; file made by Python, header included. Python's zlib gets the stream to 39 bytes, one less than Node's.) Let's look at what gzip guesses with.&lt;/p&gt;

&lt;h2&gt;
  
  
  gzip's model is its own past
&lt;/h2&gt;

&lt;p&gt;DEFLATE is two algorithms stacked. The first, &lt;strong&gt;LZ77&lt;/strong&gt;, replaces repeated text with a pointer: "copy 12 bytes from 40 bytes back". The second, Huffman coding, gives shorter codes to the things that show up more often. What matters here is the first one: text that repeats is cheap, text that's new is expensive.&lt;/p&gt;

&lt;p&gt;Oh, and gzip can only look 32 KB back, that's its whole context window.&lt;/p&gt;

&lt;p&gt;So gzip predicts exactly one thing: that the text will repeat what it has already seen. On a long Wikipedia dump that's a decent bet, because a lot of patterns repeat. On one line of Shakespeare there's nothing to copy, so the bet loses.&lt;/p&gt;

&lt;h2&gt;
  
  
  Making gzip write
&lt;/h2&gt;

&lt;p&gt;If gzip's guess is "whatever compresses best", we can ask it to write with a simple loop. Take the text so far, add every possible next character, compress each version, and keep the one that came out smallest. That's the character gzip "expected". Then repeat. In an LLM this is called &lt;em&gt;greedy decoding&lt;/em&gt;, at temperature 0.&lt;/p&gt;

&lt;p&gt;We never touch gzip's code, the only question we ask it is "how many bytes is this?"&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="c1"&gt;// src/engine.ts (simplified)&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;zlib&lt;/span&gt; &lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="s1"&gt;'node:zlib'&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="no"&gt;ALPHABET&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"abcdefghijklmnopqrstuvwxyz .,':;0123456789\n"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="c1"&gt;// The only thing we ever ask gzip&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;size&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;string&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;dictionary&lt;/span&gt;&lt;span class="o"&gt;?:&lt;/span&gt; &lt;span class="nc"&gt;Buffer&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt;
  &lt;span class="n"&gt;zlib&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;deflateRawSync&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;level&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;9&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;dictionary&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;length&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="c1"&gt;// The next character gzip "expects": the one that keeps the output smallest&lt;/span&gt;
&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;nextChar&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;string&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;dictionary&lt;/span&gt;&lt;span class="o"&gt;?:&lt;/span&gt; &lt;span class="nc"&gt;Buffer&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;string&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="n"&gt;best&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;ALPHABET&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="n"&gt;bestSize&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;Infinity&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt; &lt;span class="k"&gt;of&lt;/span&gt; &lt;span class="no"&gt;ALPHABET&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;s&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;size&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;text&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;dictionary&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;s&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="n"&gt;bestSize&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;best&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;bestSize&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;s&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;best&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That's the naive version, and if you run it on the sentence about the cat below, it writes "mat" and then "aaaa" forever. The talk version of this demo did the same at first. The reason is that sizes come in whole bytes, so a preference of a few bits disappears, all 43 characters tie, and the first one in the alphabet wins. The fix has two parts, and only ever uses sizes. When characters tie, the real engine continues each one for 4 more characters and keeps the one whose continuation compresses best. This is the paper's "looking multiple steps ahead". To compare those continuations it has to see differences smaller than a byte. DEFLATE writes bits but rounds the output up to whole bytes, so a difference of a few bits usually doesn't show. Adding filler of different lengths moves where that rounding falls, so the engine compresses each continuation 16 times with a different filler, and the sum shows the small differences.&lt;/p&gt;

&lt;p&gt;This is untrained gzip, with no data and nothing but the text you type:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F6g6cvzzjjd3rohrwb8cx.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F6g6cvzzjjd3rohrwb8cx.png" alt="The untrained mode of gzip chat: the cat sentence continued by copying, the Hamlet line looping on itself, and xyz turning into a row of a" width="800" height="729"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;"the cat sat on the mat. the dog sat on the log. the cat sat on the " becomes "&lt;strong&gt;mat. the dog sat on the log. the cat sat&lt;/strong&gt;". It copies.&lt;/li&gt;
&lt;li&gt;"to be or not to be, that is the " becomes "&lt;strong&gt;or not to be, that is the or not to be&lt;/strong&gt;". It loops, because the cheapest thing to write is a copy of what it just wrote.&lt;/li&gt;
&lt;li&gt;"xyz" becomes "&lt;strong&gt;aaaaaaaa&lt;/strong&gt;". Nothing to copy, no preference.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;So gzip can write, but only what it has already read. Let's give it something to read!&lt;/p&gt;

&lt;h2&gt;
  
  
  Training gzip
&lt;/h2&gt;

&lt;p&gt;zlib has a feature called the &lt;strong&gt;preset dictionary&lt;/strong&gt;: text that gzip reads before it starts compressing, as if it had already seen it. (Strictly speaking it's a DEFLATE feature: the &lt;code&gt;.gz&lt;/code&gt; file format has no room for a dictionary, so the code calls raw DEFLATE.) Whatever is in the dictionary becomes cheap to copy. That's gzip's "training data", and like its memory, it's capped at 32 KB.&lt;/p&gt;

&lt;p&gt;I first did this for a talk. I gave gzip the talk's own notes plus a few questions and answers, and let the room ask it things. Highlight of the talk, if you ask me.&lt;/p&gt;

&lt;p&gt;The trick that turns completion into a chat is the format. If the dictionary is full of lines like &lt;code&gt;q: who is edo? a: a senior developer advocate...&lt;/code&gt;, and I give gzip &lt;code&gt;q: &amp;lt;your question&amp;gt;? a:&lt;/code&gt;, the cheapest continuation is an answer copied from a line that looks like yours. That's a chat template, the same trick as giving a base LLM a few example questions and answers in its prompt.&lt;/p&gt;

&lt;p&gt;It also hallucinates, with zero parameters. Ask it something it doesn't know, and it confidently copies the answer of whatever line looks closest.&lt;/p&gt;

&lt;h2&gt;
  
  
  RAG, with gzip only
&lt;/h2&gt;

&lt;p&gt;In the demo, the knowledge comes from my website: 477 questions sharing 104 answers, 26 KB. The answers are sentences from the site, lightly shortened (apart from a few about the chat itself), and a script turns the lists of talks and articles into pairs. The questions, and the many ways to word each one, were written by Kiro Crew. So yes, an LLM wrote gzip's training data.&lt;/p&gt;

&lt;p&gt;To answer, gzip first has to find the right pair. The idea is old and lovely: two texts that share a lot cost little more to compress together than apart. Compare one question with two stored ones:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;"which city is edo in?" with...&lt;/th&gt;
&lt;th&gt;Alone&lt;/th&gt;
&lt;th&gt;Together&lt;/th&gt;
&lt;th&gt;Extra bytes&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;"which city does edo live in?"&lt;/td&gt;
&lt;td&gt;26 + 33&lt;/td&gt;
&lt;td&gt;40&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;7&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;"what is the schema tax?"&lt;/td&gt;
&lt;td&gt;26 + 28&lt;/td&gt;
&lt;td&gt;48&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;20&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The first pair shares "which city ... edo ... in?", so gzip copies those words and adding the question costs almost nothing. Turn that into a number between 0 and 1 (the size together, minus the smaller one alone, divided by the bigger one) and you get the &lt;a href="https://en.wikipedia.org/wiki/Normalized_compression_distance" rel="noopener noreferrer"&gt;normalized compression distance&lt;/a&gt;: close to 0 means the same text, close to 1 means nothing in common.&lt;/p&gt;

&lt;p&gt;That number also gives gzip a way to say no. If even the closest stored question is too far away (a distance above 0.45), it doesn't copy anything. It answers "i don't know. that question surprises me too much". If your question is too surprising, gzip has nothing to copy, and my code says so with a sentence I wrote.&lt;/p&gt;

&lt;p&gt;Then it writes, with only the closest pairs as its dictionary. How many? We measured it on the 15 test questions that have an answer, with the refusal turned off, and fewer pairs work better:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;What gzip reads while writing&lt;/th&gt;
&lt;th&gt;Right answers (of 15)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;the closest pair&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;the 3 closest pairs&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;11&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;the 10 closest&lt;/td&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;the 30 closest&lt;/td&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;all 477, closest last&lt;/td&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;all 477, no retrieval&lt;/td&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;(Written out as pairs, all 477 take 54 KB, so in the last two rows gzip only sees the last 32 KB.)&lt;/p&gt;

&lt;p&gt;Every extra pair is one more place to copy from by mistake. A nice side effect: retrieval also removes the 32 KB limit, because gzip only ever reads a few hundred bytes per answer.&lt;/p&gt;

&lt;p&gt;How good is it? We scored it on 20 questions written before scoring and never added to the data. It answered 10 of the 15 it had an answer for (the refusal costs one right answer, the MCP one), and refused all 5 it had no answer for, like the president of Italy or my email address. It's a demo number, not a benchmark, before you quote it.&lt;/p&gt;

&lt;p&gt;The failures are more interesting than the score.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4o4jzyjbwnajf97649hp.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4o4jzyjbwnajf97649hp.png" alt="gzip chat answering &amp;quot;does edo have kids?&amp;quot; correctly, and &amp;quot;does edo have offspring?&amp;quot; with the description of the podcast" width="800" height="729"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;"does edo have kids?" works, because someone wrote "kids" down. To gzip, "does edo have offspring?" is exactly as far from "does edo have a podcast?" as from "does edo have kids?" (eight stored questions tie). The podcast one comes first in the file, so I get my podcast described to me. gzip matches &lt;strong&gt;bytes&lt;/strong&gt;, not &lt;strong&gt;meaning&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;The second kind is subtler: even when retrieval finds the right question, gzip can copy the wrong answer, when two answers cost exactly the same bytes and the alphabet breaks the tie.&lt;/p&gt;

&lt;h2&gt;
  
  
  How it runs
&lt;/h2&gt;

&lt;p&gt;gzip chat is one Node.js HTTP server with no dependencies, deployed as an &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/web-functions.html" rel="noopener noreferrer"&gt;AWS Lambda Web Function&lt;/a&gt; behind Amazon CloudFront.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgn0c7wnp6ocz8vqh4bj4.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgn0c7wnp6ocz8vqh4bj4.png" alt="The browser calls Amazon CloudFront, which caches answers. The first time a question is asked, CloudFront forwards it, signed with SigV4, to the gzip-chat Lambda Web Function in eu-west-1, which holds zlib and 26 KB of Q&amp;amp;A" width="800" height="302"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;gzip is deterministic: the same question always gets the same answer. So CloudFront caches every answer for a day (the question travels in the URL, so it's the cache key), and only the first person to ask something new wakes the function. A new answer takes from a few milliseconds to under two seconds of CPU, and the function scales to zero when nobody is asking.&lt;/p&gt;

&lt;p&gt;One confession: the letter-by-letter typing on the page is theatre. The server sends the whole answer at once, and the page animates it so you can watch it like a chat. In the next version I will add some "discombobulating..." somewhere.&lt;/p&gt;

&lt;p&gt;The code is on &lt;a href="https://github.com/edodusi/gzip-chat" rel="noopener noreferrer"&gt;GitHub&lt;/a&gt;, with the eval (&lt;code&gt;npm run eval&lt;/code&gt;), a one-command deploy and a teardown script.&lt;/p&gt;

&lt;h2&gt;
  
  
  So, is gzip an LLM?
&lt;/h2&gt;

&lt;p&gt;NO!&lt;/p&gt;

&lt;p&gt;gzip makes almost every choice: every letter of an answer, which stored question is closest, when an answer ends. I wrote the rules and the data: the knowledge file, the &lt;code&gt;q: ... a:&lt;/code&gt; template, the 0.45 cutoff, the 3 pairs, the refusal sentence. When it answers right, it has almost always copied a stored answer word for word. It's a search engine with a copy machine attached. A RAG in miniature.&lt;/p&gt;

&lt;p&gt;In my opinion that's still a good way to understand how an LLM chatbot works, just in reverse. An LLM chatbot has the same parts: a model that predicts the next token, and around it the chat template, the retrieval, the system prompt and the stop rules, code that people wrote. We call this the &lt;strong&gt;harness&lt;/strong&gt;. In gzip chat the harness does almost all the work, because the model can only copy.&lt;/p&gt;

&lt;p&gt;An LLM learned from billions of sentences that "kids" and "offspring" show up in the same places, so it knows they mean the same thing, and nobody has to write down every wording or decide for it when to say "i don't know". gzip only remembers bytes, so every way to say something has to be written down for it. That's what all those parameters buy you: a thin harness. And it's why an LLM had to write gzip's "training data".&lt;/p&gt;

&lt;p&gt;Both of them only send you what you couldn't guess. The better the guesser, the less the rest of the system has to do.&lt;/p&gt;

</description>
      <category>llm</category>
      <category>compression</category>
      <category>aws</category>
      <category>serverless</category>
    </item>
    <item>
      <title>SQL vs NoSQL on AWS (Aurora, RDS or DynamoDB)</title>
      <dc:creator>Ifeanyi O.</dc:creator>
      <pubDate>Sun, 15 Nov 2026 23:51:52 +0000</pubDate>
      <link>https://dev.to/aws/sql-vs-nosql-on-aws-aurora-rds-or-dynamodb-3kp3</link>
      <guid>https://dev.to/aws/sql-vs-nosql-on-aws-aurora-rds-or-dynamodb-3kp3</guid>
      <description>&lt;h2&gt;
  
  
  Intro
&lt;/h2&gt;

&lt;p&gt;A database is one of the few architecture decisions that can be expensive to reverse. Pipelines can get replaced and caches get swapped easily, but by the time you know whether the database choice was right, you already have a schema, query layer and production data that must move together.&lt;/p&gt;

&lt;p&gt;Consider our working example:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;em&gt;You're a software engineer at REXTECH, a company that operates public EV charging stations across the United States and you've been handed the next version of their platform along with ownership of the data layer. The platform does three jobs:&lt;/em&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;em&gt;Drivers open an app to find charging stations near them and see which connectors are free&lt;/em&gt;&lt;/li&gt;
&lt;li&gt;&lt;em&gt;The platform meters and bills each charging session as it happens&lt;/em&gt;&lt;/li&gt;
&lt;li&gt;&lt;em&gt;The operations team needs to know which stations are busy, which are failing and what revenue looks like by region&lt;/em&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;em&gt;REXTECH runs all this today on a single PostgreSQL database in their own data center. It uses PostGIS, an open-source extension that adds geospatial queries to PostgreSQL, to answer which stations fall within 5 miles of a driver and a trigger writes an audit row every time a session closes.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;The company is moving to AWS and opening its first European stations next year, which means the data layer has to be chosen rather than inherited.&lt;/em&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;This article walks through how to make that decision, beginning with a framing that sends many teams to the wrong answer.&lt;/p&gt;

&lt;h2&gt;
  
  
  SQL vs. NoSQL framing falls short
&lt;/h2&gt;

&lt;p&gt;The first instinct is to treat this as a choice between relational (SQL) and NoSQL, which sounds like a question about the shape of your data, but it rarely is.&lt;/p&gt;

&lt;p&gt;On AWS, there are three services that you'll most likely choose from:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Amazon DynamoDB is a fully managed key-value database where items are stored and retrieved by a key you already hold, with no instances to provision or size at any scale.&lt;/li&gt;
&lt;li&gt;Amazon Aurora is a managed relational database offering PostgreSQL-compatible and MySQL-compatible engines built for AWS, with higher throughput and storage ceilings than the community versions.&lt;/li&gt;
&lt;li&gt;Amazon Relational Database Service (Amazon RDS) is the managed service for running the standard engines directly, covering PostgreSQL, MySQL, MariaDB, SQL Server, Oracle and Db2.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;REXTECH's entire platform could be built on DynamoDB but it could just as reasonably be built on Aurora. Both are durable, both are fully managed and scale well past anything a national charging network will require. That similarity is what makes a data model comparison unhelpful, because when two options are genuinely close, the decision tends to falls back to whichever model the team knows better.&lt;/p&gt;

&lt;p&gt;The deciding factor is when you have to commit to your queries. A relational database allows you to model the data now and work out the queries later, which is what keeps an unplanned reporting question answerable years after the schema is designed. A key-value database inverts that order, asking you to work out the queries first and rewarding you with scaling characteristics that have no practical ceiling.&lt;/p&gt;

&lt;p&gt;Both options will defer something but the key decision to make is which deferral the project can afford.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 1. Write down every read operation
&lt;/h2&gt;

&lt;p&gt;This is not an inventory of the data you intend to store but every distinct way the application will retrieve it. For REXTECH, that list comes out roughly as:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Find stations within a radius of a driver's coordinates&lt;/li&gt;
&lt;li&gt;Get the current status of every connector at one station&lt;/li&gt;
&lt;li&gt;Get one charging session by session ID&lt;/li&gt;
&lt;li&gt;Get a driver's session history, most recent first&lt;/li&gt;
&lt;li&gt;Get the current billing total for an in-progress session&lt;/li&gt;
&lt;li&gt;Average utilization per station, by hour, for the last quarter&lt;/li&gt;
&lt;li&gt;Revenue by region and connector type, month over month&lt;/li&gt;
&lt;li&gt;Which stations reported a fault more than three times last week&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Those entries separate into three groups that behave differently.&lt;/p&gt;

&lt;p&gt;Entries 2 - 5 each begin from an identifier the application already holds, whether a station ID, session ID or driver ID and each returns a bounded result. These are key-based reads and DynamoDB serves them at request rates of millions of requests per second with no change to the table as traffic grows.&lt;/p&gt;

&lt;p&gt;Entries 6 - 8 are different. They don't begin from a single identifier, each one aggregates across the whole dataset along a dimension that is not a primary key and each one is a question the operations team raised recently rather than a requirement that shipped with the platform. A relational database answers all three with ordinary queries against the schema you already have. However, DynamoDB needs a separate secondary index, designed in advance, for every one of them.&lt;/p&gt;

&lt;p&gt;Entry 1 sits outside both groups, because finding stations near a driver is a geospatial query that needs PostGIS, that runs only on PostgreSQL, so that read is decided by which engine you pick rather than how you access the data.. The list is the first step in answering the more important question of knowing how confident you are that the list is complete.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 2. Test whether list is complete
&lt;/h2&gt;

&lt;p&gt;For entries 2 - 5, confidence is high. Those reads are determined by what the charging hardware does, so they will most likely look the same in three years. For entries 6 - 8, confidence is close to zero, because we anticipate the operations team or finance team asking for another requirement next quarter that wasn't accounted for.&lt;/p&gt;

&lt;p&gt;This produces three outcomes encountered by REXTECH .&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where a group of reads is short, key-based and confidently final, DynamoDB is the answer.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;For REXTECH that group is entries 2 - 5, the connector status read and the three session reads. Design the partition key and sort key around them and there are no instances to size and no capacity planning, because on-demand capacity mode adjusts throughput as traffic changes.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where the list cannot be finished, Aurora or RDS is the answer.&lt;/strong&gt; REXTECH's operations and finance queries are the clearest instance of this. If you cannot finish the list, that in itself tells you queries will arrive which you cannot design for today. A relational schema queried with SQL is well suited to exactly that, since the schema describes the data rather than a specific read path.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where the list is complete but contains joins or aggregations, Aurora or RDS is again the answer.&lt;/strong&gt; Entries 6 - 8 are aggregations, and DynamoDB has no built-in aggregation, so each would need precomputed totals maintained as sessions are written, usually through DynamoDB Streams and a Lambda function. However, a relational engine offers all three directly from the tables that already exist.&lt;/p&gt;

&lt;p&gt;Most teams cannot finish the list and that is the single most common reason they'll choose relational. What's not accounted for in this execercise is how hard requiremesnts can override this process.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 3. Check the requirements that override decision
&lt;/h2&gt;

&lt;p&gt;The read list gives you a starting answer but it's not neccesarily the final one. Three requirements can override it, which REXTECH runs into.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A dependency on a specific engine feature.&lt;/strong&gt; Finding stations near a driver requires PostGIS and that requirement will decide station search before access patterns enter the conversation, pointing to Aurora PostgreSQL or RDS for PostgreSQL. The same reasoning applies to pgvector for vector search, pg_trgm for fuzzy text matching and to procedural languages and triggers. Check for this first, since it can eliminate options before you evaluate anything else.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;An existing database being migrated.&lt;/strong&gt; REXTECH already runs PostgreSQL with a working schema and a trigger the audit process depends on and between Aurora and RDS there are nine engines to choose from, so the odds are good one of them already speaks what the application speaks. In practice, using what the application already expects, offers less complexity and is more desired by teams than moving to new cleaner design.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Write throughput beyond a single instance.&lt;/strong&gt; If REXTECH's writes eventually exceed what one Aurora instance can absorb, or if drivers on two continents need to write to the same logical database, relational options exist rather than an automatic move to DynamoDB. Aurora PostgreSQL Limitless Database shards automatically while preserving a single-database experience, and Aurora DSQL is a serverless distributed SQL database, also PostgreSQL-compatible, that spreads writes across Regions with active-active replication and strong consistency. You no longer have to leave SQL behind to scale writes horizontally. Two parts of that need unpacking though involving what serverless actually means across these services and where Aurora DSQL draws its line.&lt;/p&gt;

&lt;h2&gt;
  
  
  Things that trip teams up
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Serverless tends to means two different things.&lt;/strong&gt; Serverless operations means there are no instances to provision, size or patch, so you receive an endpoint and begin querying, which is how DynamoDB, Aurora DSQL and Amazon Keyspaces work. Serverless capacity means you still create and operate a cluster while its compute and storage scale automatically, which is what Aurora PostgreSQL and Aurora MySQL offer as Aurora Serverless v2. One removes the cluster and the other removes the capacity planning, so if the goal is fewer things to operate rather than a smaller bill, serverless capacity does not neccesserilly achieve it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Aurora DSQL draws its line at the schema.&lt;/strong&gt; It supports foreign keys, table relationships, JOIN operations and views, so having a relational schema is not grounds for ruling it out, which is the reason teams most often cite. What decides it is whether the rest of the schema fits a deliberately smaller PostgreSQL surface. Triggers, stored procedures and temporary tables are not supported, each cluster holds a single database and transaction isolation is fixed at Repeatable Read. Two constraints shape application code: a single transaction can modify up to 3,000 rows, so REXTECH's nightly billing batch has to be chunked, and optimistic concurrency control returns a serialization error at commit rather than blocking on a lock, so the application needs retry logic with backoff.&lt;/p&gt;

&lt;h2&gt;
  
  
  REXTECH's decision
&lt;/h2&gt;

&lt;p&gt;Charging sessions, billing and the operations and finance queries go to Aurora PostgreSQL, supported by four independent reasons pointing the same direction. The read list cannot be completed, the queries require joins and aggregates, an existing PostgreSQL schema is worth preserving and PostGIS handles station search. Connector status goes to DynamoDB, where the list is short, key-based and stable for the service life of the hardware, and where the platform's highest-volume read benefits most from an engine that absorbs traffic growth without intervention.&lt;/p&gt;

&lt;h2&gt;
  
  
  How you can begin today
&lt;/h2&gt;

&lt;p&gt;Start with the list. Write down every distinct read the application performs, including the ones that feel obvious, then mark each with how confident you are that it will still be there in a couple years. Where a group of reads is short, key-based and complete, design a DynamoDB table around it. Where the list cannot be finished, or where it needs joins and aggregations, choose Aurora or RDS. Then check the result against the three overrides, since an extension dependency, a migration or write volume beyond one instance will override whatever the access patterns are.&lt;/p&gt;

&lt;p&gt;One caution if you verify any of this with a coding assistant. Three specifics in this post changed within roughly the last year and a model's training data has a cutoff that service limits do not respect. AWS publishes reusable skills through the &lt;a href="https://aws.amazon.com/products/developer-tools/agent-toolkit-for-aws/?trk=9863b7a2-22fd-49a4-9719-adca9eb72872&amp;amp;sc_channel=ps&amp;amp;ef_id=EAIaIQobChMIyZ2hsPyFmAMVk7SuBR3xigPhEAAYASAAEgLTL_D_BwE:G:s&amp;amp;gads_camp=23532468220&amp;amp;gads_ag=202990383729&amp;amp;gads_ad=825079690030&amp;amp;gads_kw=aws%20agent%20toolkit&amp;amp;gads_matchtype=e&amp;amp;gads_network=g&amp;amp;gads_device=c&amp;amp;gads_geo=9197808&amp;amp;gad_campaignid=23532468220&amp;amp;gbraid=0AAAAADjHtp9tBoroOTb4-LucFSCpb-IY_&amp;amp;gclid=EAIaIQobChMIyZ2hsPyFmAMVk7SuBR3xigPhEAAYASAAEgLTL_D_BwE" rel="noopener noreferrer"&gt;Agent Toolkit for AWS&lt;/a&gt; for this, including one that routes database questions to current service guidance. Leverage it to confirm the limits your design depends on to guide you in making a decision.&lt;/p&gt;

&lt;h2&gt;
  
  
  Additional resources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://docs.aws.amazon.com/decision-guides/latest/decision-guides/databases-on-aws-how-to-choose.html" rel="noopener noreferrer"&gt;Choosing an AWS database service&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/data-modeling.html" rel="noopener noreferrer"&gt;Modeling data in DynamoDB&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://docs.aws.amazon.com/aurora-dsql/latest/userguide/working-with-postgresql-compatibility-supported-sql-features.html" rel="noopener noreferrer"&gt;Aurora DSQL supported SQL features&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless-v2.html" rel="noopener noreferrer"&gt;Aurora Serverless v2 scaling and capacity&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Authored by:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.linkedin.com/in/ifeanyiotuonye/" rel="noopener noreferrer"&gt;&lt;strong&gt;Ifeanyi Otuonye&lt;/strong&gt;&lt;/a&gt; Developer Experience Engineer, AWS&lt;/p&gt;

</description>
      <category>dynamodb</category>
      <category>aws</category>
      <category>sql</category>
      <category>nosql</category>
    </item>
    <item>
      <title>How emulators might catch what you might miss</title>
      <dc:creator>Salih Guler </dc:creator>
      <pubDate>Wed, 11 Nov 2026 18:07:48 +0000</pubDate>
      <link>https://dev.to/aws/how-emulators-might-catch-what-you-might-miss-34hd</link>
      <guid>https://dev.to/aws/how-emulators-might-catch-what-you-might-miss-34hd</guid>
      <description>&lt;p&gt;I build plenty of apps due to the nature of my job. I use coding agents extensively. I decide what gets built and review what the agent writes. Tests are a big part of my development process as it ensures that whatever my agents build is up to standard.  &lt;/p&gt;

&lt;p&gt;Recently, I was working on a game that allows users to work as a bartender. In this game, you are expected to take orders, deliver them, and charge your customers. When the agent built the feature for charging the customers, it actually implemented a false-positive test: the test passed, but it shouldn’t have. In the application, orders arrive through an &lt;a href="https://aws.amazon.com/sqs/" rel="noopener noreferrer"&gt;Amazon Simple Queue Service (Amazon SQS)&lt;/a&gt; queue. One of its tests simulated a crashed worker by charging an order and then forgetting to delete the message, forcing the message to be redelivered. The agent used the receipt handle as its key to prevent double-charging.  Because SQS generates a new receipt handle for each delivery of the message, the check didn't recognize the order. This means the customer would have paid twice. &lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxk1n4sitrml6arqlhag0.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxk1n4sitrml6arqlhag0.png" alt="An order flows from the customer through the Amazon SQS queue to the bartender and the tab. A forgotten DeleteMessage sends the same order back to the queue with a new receipt handle." width="799" height="415"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;How could we have prevented this? Mocking an AWS service’s response works well for the happy path. But this example shows the dangers of assuming exactly what the service will return.  Every rule the service enforces must first be in the test author's head, and the mock never tells you what you left out.  &lt;/p&gt;

&lt;p&gt;To cover what you are missing, you can run the tests on the actual cloud. But this means having an infrastructure to test against. Sometimes we run thousands of tests on different branches, but that incurs costs. On top of that, integration tests are sensitive to concurrent tests modifying shared resources. An alternative is something we call emulation. An emulator acts like the service you are calling, allowing you to run your app against your target APIs on your machine. Emulators can be used for a range of use cases, from emulating the behavior of an Android phone to emulating cloud APIs.  &lt;/p&gt;

&lt;p&gt;Today we announced the &lt;a href="https://aws.amazon.com/products/developer-tools/emulator/" rel="noopener noreferrer"&gt;AWS Emulator&lt;/a&gt;, a local emulator that lets you test your AWS applications on your own machine, with no network access and no additional service fee. Your code sends the same requests to AWS Emulator instead of the cloud. The emulator checks each request, stores the data, and answers the way the service would. The rules live in the emulator, so a test can run into rules its author never thought about. It needs no deployment and no AWS account, so you can run it on every change.  &lt;/p&gt;

&lt;p&gt;When I ran the same tests for my bartender game against AWS Emulator, the order was re-delivered after its visibility timeout (the time Amazon SQS hides a message that's being handled), with a new receipt handle (the ID Amazon SQS gives each delivery). The test failed, and the agent automatically implemented a new solution that used the order id to prevent double charging. &lt;/p&gt;

&lt;h2&gt;
  
  
  How emulation got here, and where it fits
&lt;/h2&gt;

&lt;p&gt;Running AWS services on your own machine isn't new. AWS has shipped local emulators for more than a decade. DynamoDB Local came out in 2013. The AWS Serverless Application Model (AWS SAM) CLI runs AWS Lambda functions and Amazon API Gateway routes on your machine. AWS Step Functions, AWS Glue, and the Lambda runtime each have their own local tools.  &lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjvcme6ud9ctjsqgr22vl.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjvcme6ud9ctjsqgr22vl.png" alt="A timeline from DynamoDB Local in 2013 through AWS SAM CLI, Step Functions Local and LocalStack to AWS Emulator today." width="800" height="164"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;A broader ecosystem has also evolved toward helping developers emulate cloud behavior. AWS partner &lt;a href="https://www.localstack.cloud/" rel="noopener noreferrer"&gt;LocalStack&lt;/a&gt; has helped many developers test AWS applications locally for years. How well any emulator does the job depends on its fidelity, meaning how closely it answers like the real service. Waldemar Hummer, co-founder and CTO of LocalStack, sees the next step as a shared one: &lt;/p&gt;

&lt;p&gt;"&lt;em&gt;At LocalStack, we believe that cloud development should be fast, local, and accessible to every developer. AWS's investment in local cloud emulation is a testament to the role of local cloud development for the AWS community. We believe there's a significant opportunity to move the ecosystem forward together, from improving emulator fidelity and establishing open testing standards to integrating emulators of all kinds into the development experience our users rely on. LocalStack is excited to work with AWS to build on this vision of a unified emulator ecosystem.&lt;/em&gt;"&lt;/p&gt;

&lt;p&gt;We wanted to contribute to this ecosystem. Our AI agents have generated and are constantly evolving a suite of fidelity tests that they use to autonomously improve AWS Emulator’s fidelity. We’ve made both these fidelity tests and AWS Emulator’s source code available &lt;a href="https://github.com/aws/aws-emulator" rel="noopener noreferrer"&gt;on GitHub&lt;/a&gt; as a public domain dedication under CC0 1.0 license. We did this so that anyone can use them to learn from how we approached the problem or integrate them directly into their product. &lt;/p&gt;

&lt;h2&gt;
  
  
  Why emulators are so important for agents
&lt;/h2&gt;

&lt;p&gt;With the increase usage of AI coding agents, it is increasingly important for agents to be able to test end-to-end locally. This is why one of our primary focuses is building products like AWS Emulator that help customers give their agents more autonomy when building software. &lt;/p&gt;

&lt;p&gt;Every copy of AWS Emulator is isolated, with its own port, keys, and state. Several agents can each run their own copy without sharing a test account, and none of them needs credentials for your AWS account. This enables you to run multiple agents in parallel, each implementing and testing different features.  &lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9nm55cyqcz0u8truw1gc.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9nm55cyqcz0u8truw1gc.png" alt="Three coding agents each run their own copy of AWS Emulator, and none of them reaches your AWS account." width="800" height="463"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;We used similar techniques as we built AWS Emulator itself. Agents verified their implementations locally, so they could build more autonomously and with higher quality. As a result, we delivered faster, and customers got the tools they needed to innovate faster. &lt;/p&gt;

&lt;p&gt;A quote from James Greenfield, VP of AWS Platform Experience, sheds more light on this commitment: &lt;/p&gt;

&lt;p&gt;"&lt;em&gt;Our customers have been asking for high fidelity emulators. We've focused on some of our most popular services such as DynamoDB, but this has left customers without options for some of our other services. AI has enabled us to move much more quickly. Because building an emulator is particularly well suited to agentic development, we've been able to use thousands of agents to deliver a high-fidelity emulator that covers the breadth of AWS. We think customers will also love that any discovered issue is fixed in a matter of hours.&lt;/em&gt;"&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;An emulator checks your code against the service's own rules, including the ones you never thought of checking. In my project, that was the difference between a passing test and a customer paying twice. Coding agents widen the gap, because the agent that writes your code also writes your tests, including any mocks. Keep the mocks for the logic that you control. However, when your code depends on how an AWS service behaves, run it against an emulator. &lt;/p&gt;

&lt;p&gt;To get started, see the &lt;a href="https://docs.aws.amazon.com/emulator/latest/userguide/" rel="noopener noreferrer"&gt;AWS Emulator documentation&lt;/a&gt; and the &lt;a href="https://github.com/aws/aws-emulator" rel="noopener noreferrer"&gt;AWS Emulator GitHub repository&lt;/a&gt;. Also ask your coding agent to install the Emulator skill to check whether your application can run fully against the emulator. Run your tests against the emulator, and if one of your tests catches something your mocks missed, tell me about it in the comments. &lt;/p&gt;

</description>
      <category>aws</category>
      <category>testing</category>
      <category>ai</category>
      <category>devops</category>
    </item>
    <item>
      <title>Once Upon Agentic AI (Part 1): Create your own agent and forge its tools with Strands Agents</title>
      <dc:creator>TheWitcherish</dc:creator>
      <pubDate>Tue, 10 Nov 2026 08:45:56 +0000</pubDate>
      <link>https://dev.to/aws/once-upon-agentic-ai-part-1-create-your-own-agent-and-forge-its-tools-with-strands-agents-22mo</link>
      <guid>https://dev.to/aws/once-upon-agentic-ai-part-1-create-your-own-agent-and-forge-its-tools-with-strands-agents-22mo</guid>
      <description>&lt;p&gt;On Day1, three heroes that nothing destined to cross went on a journey to write the same legend. &lt;a href="https://github.com/TheWitcherish" rel="noopener noreferrer"&gt;TheWitcherish&lt;/a&gt; from the Order of Developers, &lt;a href="https://amagash.github.io/" rel="noopener noreferrer"&gt;Amagash&lt;/a&gt; from the Order of Agents, and &lt;a href="https://tagazok.github.io/" rel="noopener noreferrer"&gt;Tagazok&lt;/a&gt; from the Order of Builders.&lt;br&gt;
And high above it all, an &lt;a href="https://builder.aws.com/community/@nataliastones?tab=articles" rel="noopener noreferrer"&gt;Orchestrator&lt;/a&gt; agent watched over this world.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fyj37q6vp69iwebxea34l.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fyj37q6vp69iwebxea34l.webp" title="Three heroes - TheWitcherish, Amagash, Tagazok" alt="Three heroes - TheWitcherish, Amagash, Tagazok" width="576" height="760"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The series follows the adventure in three parts:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;This article&lt;/strong&gt;: Create your first agent, equip it with a Vended tool, then write a tool of your own.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Part 2&lt;/strong&gt;: MCP (Model Context Protocol) explored via the MCP Inspector and Strands Agents Harness SDK.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Part 3&lt;/strong&gt;: RAG (Retrieval-Augmented Generation), A2A (Agent2Agent) and structured output with an orchestrator agent leading specialized agents.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;By the end of Part 1, your agent tells a story, looks up a spell in a real rules API, and rolls real dice with a power you wrote. You'll also be able to prove each of those from the log.&lt;/p&gt;
&lt;h2&gt;
  
  
  Get started
&lt;/h2&gt;

&lt;p&gt;To complete our heroes quest, you need Python, &lt;a href="https://docs.astral.sh/uv/" rel="noopener noreferrer"&gt;uv&lt;/a&gt;, a terminal, and AWS credentials with access to Amazon Bedrock.&lt;br&gt;
As our three heroes share one adventure, you write the code behind each step of their quest with &lt;a href="https://strandsagents.com/" rel="noopener noreferrer"&gt;Strands Agents&lt;/a&gt;, an open source SDK for AI agents in Python and TypeScript.&lt;/p&gt;

&lt;p&gt;The code lives in &lt;a href="https://github.com/aws-samples/sample-once-upon-agentic-ai" rel="noopener noreferrer"&gt;aws-samples/sample-once-upon-agentic-ai&lt;/a&gt;. The &lt;code&gt;main&lt;/code&gt; branch contains skeletons with &lt;code&gt;# TODO&lt;/code&gt; markers.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git clone https://github.com/aws-samples/sample-once-upon-agentic-ai.git ~/sample-once-upon-agentic-ai
&lt;span class="nb"&gt;cd&lt;/span&gt; ~/sample-once-upon-agentic-ai
uv sync
&lt;span class="kd"&gt;export&lt;/span&gt; &lt;span class="nv"&gt;AWS_PROFILE&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;YOUR_AWS_PROFILE &lt;span class="nv"&gt;AWS_REGION&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;YOUR_AWS_REGION
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;No AWS profile yet? The Strands Agents &lt;a href="https://strandsagents.com/docs/user-guide/sdk/model-providers/amazon-bedrock/" rel="noopener noreferrer"&gt;Amazon Bedrock model provider guide&lt;/a&gt; shows how to set up AWS credentials (with &lt;code&gt;aws configure&lt;/code&gt;, environment variables, a boto3 session, or &lt;code&gt;aws login&lt;/code&gt;) and lists the IAM permissions your agent needs to invoke a model. Strands picks those credentials up on its own.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why do we call AI Agents... agents?
&lt;/h2&gt;

&lt;p&gt;Well, agents do have agency, that is why we call them agents. Both words come from the Latin &lt;em&gt;agere&lt;/em&gt;, "to act". A model on its own only answers. An agent decides what to do next and acts on it, using the tools you give it.&lt;/p&gt;

&lt;p&gt;An agent has three parts: a model, a system prompt with its instructions, and tools it may use. When you send a message, the model decides whether to call a tool. It reads the result, then answers or calls another tool. That cycle is the agent loop. Strands runs it for you, handling model calls, tool runs, and conversation history while you write the instructions and tools.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzhmafe6bjpvpnjfw2me8.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzhmafe6bjpvpnjfw2me8.webp" title="The agent loop" alt="The agent loop" width="799" height="667"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Here is what each part gives our heroes:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Our heroes need to...&lt;/th&gt;
&lt;th&gt;Which means...&lt;/th&gt;
&lt;th&gt;Strands gives us...&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Think and decide&lt;/td&gt;
&lt;td&gt;A brain that reads and chooses what to do&lt;/td&gt;
&lt;td&gt;A model on Amazon Bedrock (default model provider)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Know who they are&lt;/td&gt;
&lt;td&gt;A standing instruction&lt;/td&gt;
&lt;td&gt;A system prompt&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Act beyond words&lt;/td&gt;
&lt;td&gt;Reaching outside the model&lt;/td&gt;
&lt;td&gt;Tools: ready-made ones from &lt;code&gt;strands.vended_tools&lt;/code&gt;, or your own with &lt;code&gt;@tool&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Step 1 gives the model its system prompt. Steps 2 and 3 give it tools.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 1: Does an agent need more than one line?
&lt;/h2&gt;

&lt;p&gt;"Our heroes had just arrived in the realm. No map, no weapons, not a single spell." Your first agent arrives the same way: a voice, and nothing in its hands.&lt;/p&gt;

&lt;p&gt;Summons it with debug logs, a system prompt, and one call:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;strands&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;Agent&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;logging&lt;/span&gt;

&lt;span class="n"&gt;logging&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;getLogger&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"strands"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;setLevel&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;logging&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;DEBUG&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;logging&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;basicConfig&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="nb"&gt;format&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"%(levelname)s | %(name)s | %(message)s"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;handlers&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;logging&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;StreamHandler&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;agent&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Agent&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;system_prompt&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"You are a game master for a fantasy role-playing game"&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;response&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;agent&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"Hi, I am an adventurer ready for adventure!"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;Agent(system_prompt=...)&lt;/code&gt; gives the model an instruction for every turn. Here it makes the agent the storyteller of a fantasy role-playing game. Without a model argument, Strands uses Amazon Bedrock with Claude Sonnet 4.6 by default. Bedrock is a serverless AWS service that runs models from several providers for you behind its APIs, so trying another model means changing a model ID, not rewriting your agent.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;cd&lt;/span&gt; ~/sample-once-upon-agentic-ai/1_strands_basics
uv run python simple_agent.py
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The debug logs show what the SDK does:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;DEBUG | strands.models.bedrock | config=&amp;lt;{'model_id': 'global.anthropic.claude-sonnet-4-6', ...}&amp;gt; | initializing
DEBUG | strands.tools.registry | tool_count=&amp;lt;0&amp;gt; | tools configured
DEBUG | strands.models.bedrock | request=&amp;lt;{'modelId': 'global.anthropic.claude-sonnet-4-6', 'messages': [...], 'system': [...]}&amp;gt;
DEBUG | strands.event_loop._retry | stop_reason=&amp;lt;end_turn&amp;gt; | model call succeeded, ...
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;One request, no tools, and &lt;code&gt;stop_reason=&amp;lt;end_turn&amp;gt;&lt;/code&gt;: the model finished in one turn. The agent opened a scene:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;em&gt;The torchlight flickers as you step into the worn wooden tavern. The smell of ale and woodsmoke fills the air. A grizzled barkeep eyes you from across the room.&lt;/em&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Then the barkeep added: "We don't get many fresh faces in Thornhaven these days." One sentence summoned a tavern and named a town. No map, no weapons: &lt;code&gt;tool_count=&amp;lt;0&amp;gt;&lt;/code&gt;. Keep &lt;code&gt;DEBUG&lt;/code&gt; on. The agent sounds like it knows the rules, but it has no book to check them in.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 2: Does the agent already know Fireball?
&lt;/h2&gt;

&lt;p&gt;"Before conquering anything, they first had to equip themselves."&lt;br&gt;
Our heroes enter a shop that promises everything they need. One of them is hungry. "No, we don't do burgers here," the shopkeeper answers, "but there's plenty of other stuff that should interest you."&lt;br&gt;
Our heroes expected a few trinkets; they found a treasure.&lt;/p&gt;

&lt;p&gt;A tool is a function described to the model, which decides whether to call it. A vended tool comes ready-made in &lt;code&gt;strands.vended_tools&lt;/code&gt;. Here, &lt;code&gt;http_request&lt;/code&gt; calls web APIs:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;strands&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;vended_tools&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;http_request&lt;/span&gt;

&lt;span class="n"&gt;agent&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Agent&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tools&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;http_request&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;system_prompt&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The system prompt points to &lt;a href="https://open5e.com/" rel="noopener noreferrer"&gt;Open5e&lt;/a&gt;, an open fantasy-RPG rules API, then asks: "What does the Fireball spell do, and how much damage does it deal?" Copy step 1's logging block, then run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;cd&lt;/span&gt; ~/sample-once-upon-agentic-ai/2_vended_tools
uv run python agent_with_vended_tools.py
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Here is the trace of what the SDK does:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;DEBUG | strands.tools.registry | tool_count=&amp;lt;1&amp;gt; | tools configured
DEBUG | strands.event_loop._retry | stop_reason=&amp;lt;tool_use&amp;gt; | model call succeeded, ...
DEBUG | strands.tools.executors._executor | tool_use=&amp;lt;{..., 'name': 'http_request', 'input': {'method': 'GET', 'url': 'https://api.open5e.com/v2/spells/srd_fireball/'}}&amp;gt; | streaming
Tool #1: http_request
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The first turn ends with &lt;code&gt;stop_reason=&amp;lt;tool_use&amp;gt;&lt;/code&gt;. The model built the URL, Strands ran it, and the result began &lt;code&gt;{"status": 200, "status_text": "OK", ...}&lt;/code&gt;. Only then did the agent answer:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Casting Time:&lt;/strong&gt; Action&lt;br&gt;
&lt;strong&gt;Range:&lt;/strong&gt; 150 feet&lt;br&gt;
...&lt;br&gt;
&lt;strong&gt;Failed save:&lt;/strong&gt; The target takes &lt;strong&gt;8d6 fire damage&lt;/strong&gt;.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;The API's JSON says &lt;code&gt;"range": 150&lt;/code&gt; and &lt;code&gt;"casting_time": "action"&lt;/code&gt;; the reply repeats both. You wrote no code to choose the tool: the model chose it, and the log proves it. But a shop only sells tools someone else made.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step 3: Is a function already a tool?
&lt;/h2&gt;

&lt;p&gt;"Saddlebags full and hearts light, our heroes continued on their way."&lt;br&gt;
Two of them stride ahead. Behind them, TheWitcherish leafs through the grimoire he has just acquired.&lt;/p&gt;

&lt;p&gt;Suddenly, he shouts "WAIT!" and announces an extraordinary power. The power: "It's 13h37." The party is not impressed. Then comes a better idea: "you can write your own powers!" How? "All we have to do is create a function, then declare it as a tool."&lt;/p&gt;

&lt;p&gt;You turn a function into a tool with a decorator, a line beginning with &lt;code&gt;@&lt;/code&gt; above the function. In Strands, it is &lt;code&gt;@tool&lt;/code&gt;. The &lt;a href="https://strandsagents.com/docs/user-guide/sdk/tools/custom-tools/" rel="noopener noreferrer"&gt;custom tools docs&lt;/a&gt; explain how Strands reads the function's docstring and type hints to build the tool specification shown to the model.&lt;/p&gt;

&lt;p&gt;Our custom tool is a dice roller, trimmed here:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;strands&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;Agent&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;tool&lt;/span&gt;

&lt;span class="nd"&gt;@tool&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;roll_dice&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;faces&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;6&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="s2"&gt;"""Roll one die with a given number of faces and return the result.
    ...
    """&lt;/span&gt;
    &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;random&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;random&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;randint&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;faces&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;dice_master&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Agent&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tools&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;roll_dice&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;system_prompt&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The system prompt makes the agent "Lady Luck", who rolls four dice for each ability score and drops the lowest. When the agent is built, the log shows the new tool being registered:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;DEBUG | strands.tools.registry | tool_name=&amp;lt;roll_dice&amp;gt;, tool_type=&amp;lt;function&amp;gt;, is_dynamic=&amp;lt;False&amp;gt; | registering tool
DEBUG | strands.tools.registry | tool_count=&amp;lt;1&amp;gt; | tools configured
agent built, tools: ['roll_dice']
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The solution prints &lt;code&gt;roll_dice.tool_spec&lt;/code&gt;, the specification sent to the model:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;{'name': 'roll_dice', 'description': 'Roll one die with a given number of faces and return the result.\n\n...', 'inputSchema': {'json': {'properties': {'faces': {'default': 6, ..., 'type': 'integer'}}, 'type': 'object'}}}
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The docstring became the description, the type hint became &lt;code&gt;'type': 'integer'&lt;/code&gt;, and the default became &lt;code&gt;'default': 6&lt;/code&gt;. The model reads this specification, not your code, so a clear docstring helps it choose the tool.&lt;/p&gt;

&lt;h2&gt;
  
  
  Time to roll the dice!
&lt;/h2&gt;

&lt;p&gt;Run the chapter:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;cd&lt;/span&gt; ~/sample-once-upon-agentic-ai/3_custom_tools
uv run python agent_with_dice_roll_tool.py
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The trace shows each step the SDK takes:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;DEBUG | strands.event_loop._retry | stop_reason=&amp;lt;tool_use&amp;gt; | model call succeeded, ...
DEBUG | strands.tools.executors._executor | tool_use=&amp;lt;{..., 'name': 'roll_dice', 'input': {'faces': 6}}&amp;gt; | streaming
...
Tool #1: roll_dice
...
Tool #16: roll_dice
DEBUG | strands.event_loop._retry | stop_reason=&amp;lt;end_turn&amp;gt; | model call succeeded, ...
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Lady Luck requested all 16 dice in one turn. Strands ran the tool 16 times, returned the results, and the second model call answered:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;STRENGTH&lt;/strong&gt;&lt;br&gt;
Rolls: 3, 1, 1, 3 -&amp;gt; Drop the &lt;strong&gt;1&lt;/strong&gt; (one of them) -&amp;gt; &lt;strong&gt;3 + 1 + 3 = 7&lt;/strong&gt;&lt;br&gt;
...&lt;br&gt;
&lt;strong&gt;CHARISMA&lt;/strong&gt;&lt;br&gt;
Rolls: 2, 6, 5, 3 -&amp;gt; Drop the &lt;strong&gt;2&lt;/strong&gt; -&amp;gt; &lt;strong&gt;6 + 5 + 3 = 14&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;The 16 tool results in the full log carry every one of those numbers, in the same groups Lady Luck used: 3, 1, 1, 3; 1, 2, 4, 3; 3, 2, 1, 2; and 2, 6, 5, 3.&lt;/p&gt;

&lt;p&gt;The log is the record. When I asked step 1's tool-free agent the Fireball question, it also said 8d6, so the reply alone can't tell you whether a tool ran. &lt;code&gt;tool_count&lt;/code&gt;, &lt;code&gt;stop_reason&lt;/code&gt; and each &lt;code&gt;Tool #&lt;/code&gt; line can.&lt;/p&gt;

&lt;p&gt;Tagazok decided to write his own custom tool decorated with &lt;code&gt;@tool&lt;/code&gt;: &lt;code&gt;def fire_sword():&lt;/code&gt;&lt;br&gt;
That is AWSome!&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9f0lp81zuqcot7f04lju.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9f0lp81zuqcot7f04lju.webp" title="Once Upon Agentic AI - Strands Agents Comic Book" alt="Once Upon Agentic AI - Strands Agents Comic Book" width="800" height="600"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Follow the adventurers
&lt;/h2&gt;

&lt;p&gt;In Part 2, our heroes seek help beyond their own strength. We equip them with an MCP server as another monster, greater and mightier, awaits them!&lt;/p&gt;

&lt;p&gt;Until then, three habits for your own agent:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Start with the system prompt.&lt;/strong&gt; Settle the agent's role and rules before you add tools.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Write the docstring for the model.&lt;/strong&gt; Read the &lt;code&gt;tool_spec&lt;/code&gt; before the model does.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Let the model choose.&lt;/strong&gt; If you catch yourself writing &lt;code&gt;if&lt;/code&gt; statements to pick a tool, that rule belongs in the system prompt.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;P.S.:&lt;/strong&gt; Their adventure is also a comic book. If you would like your own copy, the &lt;a href="https://builder.aws.com/content/3JBIHBGNv5kA724pju3QPFtkXML/once-upon-agentic-ai-with-strands-agents" rel="noopener noreferrer"&gt;Once Upon Agentic AI with Strands Agents&lt;/a&gt; page lists where to buy it in North America, Europe and Asia Pacific.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;The comic book illustrations in this blog post were created and produced by &lt;/em&gt;&lt;a href="https://www.holybird.fr/" rel="noopener noreferrer"&gt;&lt;em&gt;Holy Bird&lt;/em&gt;&lt;/a&gt;&lt;em&gt;, based on the AWS workshop.&lt;/em&gt;&lt;br&gt;
All rights reserved.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>aws</category>
      <category>mcp</category>
    </item>
    <item>
      <title>Qué pasa cuando activas las funciones avanzadas en AWS</title>
      <dc:creator>Axel Espinosa</dc:creator>
      <pubDate>Fri, 06 Nov 2026 20:01:32 +0000</pubDate>
      <link>https://dev.to/aws/que-pasa-cuando-activas-las-funciones-avanzadas-en-aws-4j6e</link>
      <guid>https://dev.to/aws/que-pasa-cuando-activas-las-funciones-avanzadas-en-aws-4j6e</guid>
      <description>&lt;p&gt;Si creaste tu cuenta de AWS hace poco, lo que viste no es el AWS del que hablan la mayoría de los tutoriales. Te registraste con un social login como Google o GitHub, nunca tuviste que poner un Account ID ni configurar un usuario root, y en lugar de "cuentas" la consola te habla de "proyectos". A eso AWS le llama la nueva experiencia.&lt;/p&gt;

&lt;p&gt;La nueva experiencia te da controles que AWS gestiona por ti y te pone límites a propósito:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Una sola región&lt;/strong&gt; para todos tus proyectos.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Un subconjunto de servicios&lt;/strong&gt; disponibles.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Políticas que AWS mantiene por ti&lt;/strong&gt;, para que no tengas que escribirlas.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Un límite de gasto&lt;/strong&gt; que puede pausar tus proyectos para que no te pases del monto que tú definiste.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;La idea es que puedas aprender y construir sin preocuparte por configurar la gobernanza de una cuenta ni por llevarte una factura sorpresa.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Si quieres conocer a detalle la nueva experiencia desde el lado de quien va comenzando, Ramses Mata lo explica en &lt;a href="https://builder.aws.com/content/3KHR0SqItiRIfvXd7RugtOEpFIl/que-significa-el-nuevo-aws-para-las-personas-que-van-comenzando?trk=02b062ab-d194-401f-85b7-db6aae204076&amp;amp;sc_channel=el" rel="noopener noreferrer"&gt;Qué significa el nuevo AWS para las personas que van comenzando&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5za43jmpta7zjmx291vx.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5za43jmpta7zjmx291vx.png" alt="Activar funciones avanzadas" width="800" height="95"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Qué hay debajo de la nueva experiencia
&lt;/h2&gt;

&lt;p&gt;Debajo de esos límites está el mismo AWS de siempre, con algunas piezas configuradas por AWS:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Tus proyectos son &lt;strong&gt;member accounts&lt;/strong&gt; dentro de una &lt;strong&gt;AWS Organization&lt;/strong&gt; que AWS administra por ti.&lt;/li&gt;
&lt;li&gt;La región única y la lista de servicios son &lt;strong&gt;Service Control Policies (SCP)&lt;/strong&gt; y &lt;strong&gt;Resource Control Policies (RCP)&lt;/strong&gt; que ya están aplicadas, solo que escritas y mantenidas por AWS.&lt;/li&gt;
&lt;li&gt;El límite de gasto es un mecanismo encima de tu billing, igual que la simplificación de permisos de IAM.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Activar las funciones avanzadas te entrega las llaves de todo eso y te quita los límites.&lt;/p&gt;

&lt;h2&gt;
  
  
  ¿Qué son las funciones avanzadas?
&lt;/h2&gt;

&lt;p&gt;Si entras a &lt;code&gt;settings.aws.com&lt;/code&gt; vas a encontrar una opción que se llama "Explore advanced features", o explorar funciones avanzadas. Es la puerta para salir de la nueva experiencia y administrar tu AWS directamente: tu organización, tus políticas, tus regiones y tus costos.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Antes de poder activar las funciones avanzadas necesitas hacer un upgrade de tu cuenta a un plan de pago. &lt;a href="https://docs.aws.amazon.com/accounts/latest/reference/upgrade-account.html?trk=02b062ab-d194-401f-85b7-db6aae204076&amp;amp;sc_channel=el" rel="noopener noreferrer"&gt;Si sigues en free tier, ese botón no te va a servir. Da clic aquí para leer más.&lt;/a&gt; Y ojo, activar las funciones avanzadas no se puede revertir. No hay botón de regreso.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Lo que cambia depende de quién seas
&lt;/h2&gt;

&lt;p&gt;Si llevas años usando AWS y ya tienes experiencia manteniendo aplicaciones en producción, activar las funciones avanzadas te lleva al mismo AWS que conoces: organizaciones, acceso al root user, selector de regiones, &lt;a href="https://docs.aws.amazon.com/accounts/latest/reference/supported-services-sign-up-new.html" rel="noopener noreferrer"&gt;todos los servicios&lt;/a&gt;, IAM. Para ti es un alivio, porque no tienes que aprender nada nuevo ni hay magia oscura por debajo. Lo que viste al entrar por primera vez era la experiencia pensada para quien va empezando en la nube.&lt;/p&gt;

&lt;p&gt;Si estás aprendiendo sobre AWS, esto sí lo vas a notar. Los cuatro límites que vimos arriba desaparecen de golpe, y todo lo que AWS mantenía por ti ahora lo mantienes tú. Como decían en una película: un gran poder conlleva una gran responsabilidad.&lt;/p&gt;

&lt;p&gt;Vamos a ver qué cambia exactamente.&lt;/p&gt;

&lt;h2&gt;
  
  
  Cambios en tu organización
&lt;/h2&gt;

&lt;p&gt;En el momento que activas las funciones avanzadas pasan estas cosas. Si quieres conocer todo a detalle te recomiendo ir directamente a la &lt;a href="https://docs.aws.amazon.com/accounts/latest/reference/activate-advanced-features.html?trk=02b062ab-d194-401f-85b7-db6aae204076&amp;amp;sc_channel=el" rel="noopener noreferrer"&gt;documentación&lt;/a&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Te vuelves administrador de la AWS Organization&lt;/strong&gt; que contiene tus proyectos. Ya no es AWS quien la maneja.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Configuras un root email y un root user password&lt;/strong&gt; para tu management account. Sí, el root user clásico regresa a tu vida. Y como todo root user, se usa para emergencias y nada más.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tus proyectos se convierten en member accounts.&lt;/strong&gt; El nombre de "proyecto" desaparece y queda lo que siempre fue: una cuenta de AWS. Y ahora puedes crear más cuentas tú mismo.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tus team members pasan a llamarse workforce identities.&lt;/strong&gt; Siguen entrando igual que antes, pero ahora el identity source es configurable desde IAM Identity Center. Puedes dejar AWS Builder ID o cambiarlo a un proveedor externo.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Las SCPs y RCPs pasan a ser tuyas.&lt;/strong&gt; Antes AWS las mantenía por ti. Ahora las puedes modificar, y también las puedes romper. Como ves, es el mismo patrón en todo lo demás: más control, más responsabilidad.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Cambiar el identity source de AWS Builder ID a otro proveedor tampoco se puede revertir. Una vez que lo cambias, ya no puedes volver a habilitar Builder ID.&lt;/p&gt;

&lt;h2&gt;
  
  
  ¿Qué pasa a nivel de costos cuando activas las funciones avanzadas?
&lt;/h2&gt;

&lt;p&gt;Esta es la parte que más se siente si vienes de la nueva experiencia:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Se va tu límite de gasto.&lt;/strong&gt; Si tenías uno, desaparece, y si algún proyecto estaba pausado por haberse pasado del límite, se reactiva solito. Después de activar ya no puedes crear límites de gasto. A cambio te dan la suite completa de Billing and Cost Management: budgets, Cost Explorer, Cost Anomaly Detection. Son herramientas mejores para analizar, organizar y planear, pero ninguna pausa tus proyectos por sí sola cuando te pasas del presupuesto. El límite de gasto era lo único que frenaba, y ese freno es justo lo que pierdes al activarlas.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Se abren todos los servicios de AWS&lt;/strong&gt;, incluyendo los que no estaban en la nueva experiencia. Vale la pena leer la documentación de cada uno antes de prenderlos, porque ya nadie te va a detener.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Se habilitan todas las regiones&lt;/strong&gt;, incluyendo las opt-in, y con eso vienen las capacidades multi-región. Te sirven, por ejemplo, para que tu aplicación siga funcionando aunque una región tenga problemas.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Puedes usar IAM Access Analyzer&lt;/strong&gt;, que es muy útil justo cuando empiezas a escribir tus propias políticas.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Lo que cambia en el día a día
&lt;/h2&gt;

&lt;p&gt;La consola simplificada ya no va a estar disponible y en su lugar tienes acceso a la AWS Management Console completa, donde puedes seleccionar regiones y ves todos los servicios. Además se desbloquean varias cosas que antes no estaban:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Apagar el multi-session console support&lt;/li&gt;
&lt;li&gt;Marcar tu cuenta como HIPAA o SEC compliant&lt;/li&gt;
&lt;li&gt;Usar AWS Marketplace&lt;/li&gt;
&lt;li&gt;Trabajar con un AWS Training Partner&lt;/li&gt;
&lt;li&gt;Comprar suscripción de AWS Skill Builder Team&lt;/li&gt;
&lt;li&gt;Enterprise Agreement, contratos de Professional Services y AWS Partner Network&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  ¿Qué pasa con AWS Settings?
&lt;/h2&gt;

&lt;p&gt;AWS Settings sigue existiendo mientras uses AWS Builder ID como identity source, solo que ahora vive únicamente en &lt;a href="https://settings.aws.com/?trk=02b062ab-d194-401f-85b7-db6aae204076&amp;amp;sc_channel=el" rel="noopener noreferrer"&gt;settings.aws.com&lt;/a&gt;. Desde ahí puedes llegar a Billing, a la consola de Organizations para revisar tus SCPs y RCPs, al Account Access Manager y a IAM Identity Center.&lt;/p&gt;

&lt;p&gt;Una cosa que sí se pierde es crear proyectos dentro de esa organización. Lo que creas ahora son member accounts, y si vas a la página de configuración e intentas crear un proyecto nuevo, AWS te muestra un modal que te explica que los proyectos de tu organización ahora se administran como cuentas de AWS y que en lugar de un proyecto crees una member account.&lt;/p&gt;

&lt;h2&gt;
  
  
  Cómo prepararte antes de activar las funciones avanzadas
&lt;/h2&gt;

&lt;p&gt;Para dar el salto a las funciones avanzadas toma en cuenta lo siguiente:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Avísale a tu equipo.&lt;/strong&gt; Su acceso no cambia por default, pero la consola que van a ver sí. Y si después cambias el identity source o metes SCPs nuevas, eso sí les pega en cómo entran y qué pueden tocar.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Revisa el gasto de todos tus proyectos&lt;/strong&gt; y detecta los que fluctúan raro. Sin límite de gasto, todo lo que corra lo pagas tú. Buen momento para borrar o pausar recursos idle y aprender buenas practicas para manejar tu cuenta.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Planea los cambios a tu Organization&lt;/strong&gt; antes, no después. Si vas a usar otra región, deja lista la SCP con el &lt;code&gt;RegionFloor&lt;/code&gt; actualizado.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Si conectaste un agente de IA&lt;/strong&gt; siguiendo la guía de AWS, borra el archivo &lt;code&gt;aws-starter-rules.md&lt;/code&gt;. Ese archivo le dice a tu agente que vives en la nueva experiencia con todas sus restricciones, y en cuanto activas las funciones avanzadas esa información queda falsa. Un agente con reglas viejas te va a pelear cosas que ya son válidas.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Entonces, ¿ya necesito esas funciones avanzadas?
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ft9o76dpmsp1emuzu0iah.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ft9o76dpmsp1emuzu0iah.png" alt="Arbol de decisión para AWS" width="800" height="864"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Si ya tienes experiencia usando AWS probablemente activaste las funciones avanzadas el primer día. Para ti es el lugar donde siempre has estado y lo único que vale la pena revisar es la lista de detalles que conlleva activarlas.&lt;/p&gt;

&lt;p&gt;Si estás aprendiendo, no tienes que apresurarte. Lo que hay que preguntarte es si todavía necesitas el freno. En la práctica te vas a dar cuenta solo: te va a faltar un servicio que no viene incluido en la nueva experiencia, vas a necesitar multi-región o aplicar políticas personalizadas, y ahí la nueva experiencia se te va a quedar corta.&lt;/p&gt;

&lt;p&gt;Si todavía no te has topado con nada de eso, quédate en la nueva experiencia, configura tus limites de gasto y sigue aprendiendo.&lt;/p&gt;

&lt;h2&gt;
  
  
  Esto es todo por ahora
&lt;/h2&gt;

&lt;p&gt;Espero que te haya servido y que ya tengas con qué decidir entre saltar a las funciones avanzadas o quedarte en la nueva experiencia. Si te queda alguna duda escríbeme a &lt;a href="https://www.instagram.com/fromchiapasdev/" rel="noopener noreferrer"&gt;@fromchiapasdev.&lt;/a&gt; Y cuéntame si ya probaste la nueva experiencia o si ya construiste tu primer proyecto ahí.&lt;/p&gt;

&lt;p&gt;Fuente: &lt;a href="https://docs.aws.amazon.com/accounts/latest/reference/activate-advanced-features.html?trk=02b062ab-d194-401f-85b7-db6aae204076&amp;amp;sc_channel=el" rel="noopener noreferrer"&gt;Activate advanced AWS features&lt;/a&gt;&lt;/p&gt;

</description>
      <category>aws</category>
      <category>tutorial</category>
      <category>cloud</category>
    </item>
    <item>
      <title>AI Game Mashups: Can AI Really Turn Two Games Into One?</title>
      <dc:creator>Matheus Guimaraes</dc:creator>
      <pubDate>Thu, 29 Oct 2026 11:27:37 +0000</pubDate>
      <link>https://dev.to/aws/ai-game-mashups-can-ai-really-turn-two-games-into-one-52bd</link>
      <guid>https://dev.to/aws/ai-game-mashups-can-ai-really-turn-two-games-into-one-52bd</guid>
      <description>&lt;p&gt;Mario shooting some baddies in Halo. Minecraft inside GTA V (see Appendix: a real-world example). A social media trend has people sharing videos of what’s being branded as “AI game mashups.” The claim is that people have used AI to reverse engineer different games and mash them together into one in unexpected or cool ways... but is that the whole story?&lt;/p&gt;

&lt;p&gt;As usual, hype has a tendency to exaggerate things to create, well, more hype. So let's separate reality from fiction and explore what’s actually happening behind these demos.&lt;/p&gt;

&lt;p&gt;The good news is that there is plenty on the reality side to be mind-blown about! However, there are also some disappointing truths. At least for the time being.&lt;/p&gt;

&lt;h2&gt;
  
  
  Let's Mash Candy Crush And Call of Duty!
&lt;/h2&gt;

&lt;p&gt;Let's walk through a ridiculous combination as a practical example. Let's imagine that we want to combine Candy Crush and Call of Duty!&lt;/p&gt;

&lt;p&gt;However, simply naming two games does not constitute a plan. Like anything else, first we need to work out our requirements and architectural concerns.&lt;/p&gt;

&lt;p&gt;Here's my take: every time you reload your weapon, Candy Crush loads inside the Call of Duty gameplay and you have to complete a match-three puzzle before the reload can finish.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ft19a00e8d1r1ownq5kr2.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ft19a00e8d1r1ownq5kr2.png" alt="Concept illustration of a match-three puzzle overlay interrupting a first-person shooter reload." width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Hypothetical mashup: solve a match-three puzzle to finish reloading. AI-generated concept illustration, not a screenshot of a working mod.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;I have no idea whether that would be fun. I suspect my teammates would have opinions. But at least we now have something concrete enough to discuss.&lt;/p&gt;

&lt;p&gt;There are still decisions to make though. Does the shooter pause while you solve the puzzle? What happens if you fail? Can you cancel? Does a harder puzzle earn you more ammunition?&lt;/p&gt;

&lt;p&gt;Neither original game contains the answers so it's up to us to introduce new rules.&lt;/p&gt;

&lt;p&gt;And that is our first lesson: &lt;strong&gt;Connecting two game engines does not automatically create coherent new gameplay.&lt;/strong&gt; Somebody, potentially with AI assistance, still has to decide what the connection means and implement it.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Are We Actually Mashing Together?
&lt;/h2&gt;

&lt;p&gt;When I watch these demos, I find it useful to separate four things.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;What’s happening&lt;/th&gt;
&lt;th&gt;What it establishes&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Visual composition&lt;/td&gt;
&lt;td&gt;Images or rendered objects from different sources appear together.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Event integration&lt;/td&gt;
&lt;td&gt;Something happening in one game triggers something in another.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Gameplay orchestration&lt;/td&gt;
&lt;td&gt;New rules coordinate actions and state across the games.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Hybrid game design&lt;/td&gt;
&lt;td&gt;Those rules form a coherent experience with its own objectives, constraints and balance.&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;These can overlap. A project might combine graphics and translate a few events without sharing every part of either simulation.&lt;/p&gt;

&lt;p&gt;For example, an explosion in one game could trigger an explosion in another. That is a meaningful integration, but it doesn’t, by itself, establish that every object in both worlds can collide, that both physics engines agree, or that every mission works across the boundary.&lt;/p&gt;

&lt;p&gt;A clip can still demonstrate a specific interaction beautifully while leaving those broader questions unanswered.&lt;/p&gt;

&lt;h2&gt;
  
  
  The missing interfaces
&lt;/h2&gt;

&lt;p&gt;Ok, so how can we go about implementing our Call of Duty and Candy Crush mash-up? Well, to begin with we need to discover each game's available integration points. Then we need to find a way to connect those before finally figuring out how to coordinate the result.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. Find a way to control the relevant behaviour
&lt;/h3&gt;

&lt;p&gt;A game with a supported modding API might already expose the events and controls we need. Otherwise, investigating its internal behaviour may be necessary.&lt;/p&gt;

&lt;p&gt;For our shooter, we would need to identify a reload request and find a reliable way to defer it. For the puzzle, we need to start a challenge and detect its completion. Observing an animation on screen is different from having a dependable signal that the underlying action succeeded.&lt;/p&gt;

&lt;p&gt;This is where reverse engineering can contribute: &lt;em&gt;working out how software behaves when its original source code or a suitable interface isn’t available.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/morluto/rea" rel="noopener noreferrer"&gt;REA, or Reverse Engineer Anything&lt;/a&gt;, is one project in this area and the one behind the viral game mashups trend. Its documentation describes connecting agents to analysis tools, including Ghidra, Hopper and IDA, and returning findings that an agent can investigate further.&lt;/p&gt;

&lt;p&gt;It is indeed a pretty cool tool that gives an agent ways to inspect software. However, it is NOT a magical command that enables agents to recover an entire game’s original source project or to understand every subsystem.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Moreover, it's important to remember that runtime modification of games predates AI tools.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/soulsmods/ModEngine2" rel="noopener noreferrer"&gt;Mod Engine 2&lt;/a&gt;, for example, documents runtime patching and injection for Souls games, including Elden Ring.[3] Existing tools and community knowledge are part of the foundation here.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Build interfaces between the games
&lt;/h3&gt;

&lt;p&gt;Once we understand the relevant behaviour, we can build adapters: code that translates between what our mashup needs and what each game can actually do.&lt;/p&gt;

&lt;p&gt;From the coordinating code’s perspective, the shooter adapter might offer operations such as “defer reload” or “resume gameplay.” The puzzle adapter might offer “start challenge” and a completion event.&lt;/p&gt;

&lt;p&gt;Those are interfaces that we have to build unless the game itself provides out-of-the-box integration points, or in simpler language, hooks. This could be, for example, official support for mods. That means creating and maintaining your own adapter code, which, yes, you can also use AI to help you generate.&lt;/p&gt;

&lt;p&gt;There is an added complication: If components run in separate processes, they need a way to exchange messages, such as sockets or named pipes. This is referred to as inter-process communication, often shortened to IPC.&lt;/p&gt;

&lt;p&gt;A hook and a communication channel have different jobs. A hook can intercept behaviour inside a game whereas IPC lets separate processes exchange information. Having one doesn’t automatically give us the other.&lt;/p&gt;

&lt;p&gt;Either way, we arrive at our second lesson: AI doesn't somehow make two incompatible executables magically understand each other. &lt;em&gt;The real magic is that AI can help us build the missing interfaces between them.&lt;/em&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Implement the new rules
&lt;/h3&gt;

&lt;p&gt;Now we need the coordinator, or orchestrator, that implements our reload rule so we can load Candy Crush every time you need to reload your weapon on Call of Duty.&lt;/p&gt;

&lt;p&gt;Here's the plan: it receives a reload request, defers the action, puts the shooter into an appropriate paused state, and opens the puzzle. On success, it allows the reload to proceed and returns control to the shooter.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fuq121jt80wqgvsrvgdnp.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fuq121jt80wqgvsrvgdnp.png" alt="Flow diagram showing the reload request, deferred reload, paused shooter, puzzle outcome, and success or recovery paths." width="800" height="765"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;The orchestrator coordinates the reload and puzzle, with a recovery path for failure, cancellation or timeout. This conceptual flow assumes the required integration points exist.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;What if the puzzle crashes though? The player shouldn’t remain trapped forever with a frozen gun. And how about if a completion message arrives twice? We need to be careful not to grant ammunition twice. Like any piece of software we need to design for our error conditions.&lt;/p&gt;

&lt;p&gt;This is why “pause the game” deserves scrutiny. Preventing player input is different from pausing the simulation. In a networked game, the server and other players may continue regardless. Our example depends on capabilities that may be unavailable or prohibited in a protected online title.&lt;/p&gt;

&lt;p&gt;If you work with microservices, there’s a familiar architectural idea here. Connecting two services doesn’t automatically create an e-commerce application. You still need rules that define what placing an order means, what happens next, and how failure is handled.&lt;/p&gt;

&lt;p&gt;Games add another difficulty, one that becomes our third lesson: &lt;em&gt;we still need to design and build gameplay rules for the mashup much like building any other game.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Do the games become one program?
&lt;/h2&gt;

&lt;p&gt;They don’t have to.&lt;/p&gt;

&lt;p&gt;In one possible implementation of our example, the shooter and puzzle remain separate processes while our own coordinator manages their behaviour and presentation.&lt;/p&gt;

&lt;p&gt;The simplest implementation may be, for example, switching back and forth between  the Candy Crush puzzle’s window and the Call of Duty window. A more integrated version could display the puzzle within the shooter’s view as ensioned in our concept above. We'll have to work harder for it because it then adds rendering and input-routing work but it does look super cool. Either way, the objective is to have the player experience a single set of rules while multiple programs do the work.&lt;/p&gt;

&lt;p&gt;Another consideration is whether we need to create our own launcher app. This could gives even more control over the runtime and coordination between the two processes running either game, however it does not automatically give control over either game's internals. &lt;/p&gt;

&lt;p&gt;So lesson four is: &lt;em&gt;the desired user experience dictates how much control you need to have over either game and determines the architectural choices as well as the amount of code that you need to write and maintain.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Where did the graphics come from?
&lt;/h2&gt;

&lt;p&gt;This is perhaps the most intriguing question.&lt;/p&gt;

&lt;p&gt;A newly written game might use original artwork, generated assets, placeholders or reused material. A mod might leave the original game’s engine and assets in place. A mashup might combine output from two running engines, each rendering its own content.&lt;/p&gt;

&lt;p&gt;Those are different workflows. A familiar character on screen doesn’t tell you which one happened.&lt;/p&gt;

&lt;p&gt;In our hypothetical example, if both original games were running, neither would need its graphics recreated merely to appear in the experience. Each game already knows how to render its own world. The integration challenge would concern control, communication, presentation and the new rules.&lt;/p&gt;

&lt;p&gt;Conversely, reproducing familiar graphics in a newly written program doesn’t establish that the original physics, enemy behaviour, timing or levels have been reproduced.&lt;/p&gt;

&lt;p&gt;But hang on. If we put Mario inside Halo, how does he know where the floor is? Doesn’t he come with his own bounding box? The important distinction is that &lt;strong&gt;a character’s appearance and its collision behaviour are separate things&lt;/strong&gt;. A visible model doesn’t automatically bring a working physics system with it. &lt;/p&gt;

&lt;p&gt;For a hypothetical model replacement, we could give an existing Halo character Mario’s appearance while keeping the host character’s movement and collision setup. Or, if we were adding a new character, we would need to create or convert the collision data into a form the host engine understands and configure its behaviour. Halo wouldn’t need to recognise “Mario”; it would need a correctly configured character in its own simulation. That could stop him falling through the floor without reproducing how he moves in a Mario game.&lt;/p&gt;

&lt;p&gt;So lesson number five is: &lt;strong&gt;Looking like two worlds have merged does not mean that their physics have merged too. There's work to be done to make that happen.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Asset provenance and permission are also separate questions from whether an integration works. A clip alone cannot answer them. Before making claims about how a creator obtained the assets, we need their documentation.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where does the AI fit?
&lt;/h2&gt;

&lt;p&gt;We should distinguish AI helping build the mashup from AI running it.&lt;/p&gt;

&lt;p&gt;During development, an agent can use tools to investigate behaviour, propose integration code and help iterate on failures. REA’s documented workflow, for example, lets an agent inspect findings, ask follow-up questions, and write and test an implementation.[2]&lt;/p&gt;

&lt;p&gt;But once our reload rule works, it can run as ordinary deterministic code. Receive the event, start the puzzle, wait for a result, update the state. There is no inherent need to ask a language model what should happen every time the player reloads.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;AI can be the engineer that builds the bridge without being the driver that crosses it.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;That distinction also helps us evaluate claims about speed. A successful demo shows that someone achieved a result. Understanding how much AI accelerated it requires more evidence: the starting tools, existing mods, development history, human interventions and failed attempts. The finished clip doesn’t contain that history.&lt;/p&gt;

&lt;h2&gt;
  
  
  Appreciate the demo. Be precise about the claim.
&lt;/h2&gt;

&lt;p&gt;I find this trend exciting because it opens up questions about what people might build when investigating and connecting unfamiliar software becomes more accessible. Not to mention that level of creativity which makes me smile or even laugh out loud every time I see one out there.&lt;/p&gt;

&lt;p&gt;But, if we're gonna get down to the nitty and gritty and talk technical, I scrutinize them about what they're trying to prove. What is running? How much of it is custom integration and coordination code? Which information crosses the boundary? Which interactions actually work? Where does the AI contribute?&lt;/p&gt;

&lt;p&gt;An overlay, an event bridge and a hybrid game can all be worthwhile achievements. Describing them accurately gives the people building them credit for the work they actually did, and gives everyone else a better understanding of what remains unsolved.&lt;/p&gt;

&lt;p&gt;Reverse engineering exposes capabilities. Integration connects them. Orchestration gives them new meaning. &lt;/p&gt;

&lt;p&gt;Whatever the path you take, ultimately it comes down to our final lesson number six: &lt;em&gt;AI or no AI, REA or whatever comes next...game mashups are a project like any other and still take a lot of work!&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;As for whether solving Candy Crush puzzles before reloading a gun in Call of Duty is a good idea...that is up for debate!&lt;/p&gt;




&lt;p&gt;&lt;a id="appendix-a-real-world-example"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Appendix: A real-world example
&lt;/h2&gt;

&lt;p&gt;The &lt;a href="https://github.com/rehan-remade/universal-modder" rel="noopener noreferrer"&gt;Universal Modder repository&lt;/a&gt; documents a Minecraft and GTA V story-mode example. Its description identifies a Minecraft Fabric mod, a ScriptHookV component and a ReShade add-on, with camera, ground and event information exchanged over a local WebSocket connection. It also describes combining Minecraft’s colour and depth output with GTA’s frame, and translating selected Minecraft events into GTA effects.[1]&lt;/p&gt;

&lt;p&gt;There are two useful ideas in that description.&lt;/p&gt;

&lt;p&gt;First, the games have specific integration components. A communication channel carries information, but code still has to decide what to send and what the receiving game should do with it.&lt;/p&gt;

&lt;p&gt;Second, presentation and interaction are separate problems. Depth information helps decide which rendered surfaces should appear in front of others. That can make the combined image convincing. Making an object affect the other game’s simulation requires additional behaviour.&lt;/p&gt;

&lt;p&gt;That is a substantial achievement. It is also a much more precise claim than “any two games can now be merged.” The project’s documented approach is evidence about that example, not a universal explanation for every viral mashup.&lt;/p&gt;




&lt;h3&gt;
  
  
  Sources
&lt;/h3&gt;

&lt;p&gt;Project documentation checked on 20 October 2026; collision reference added on 29 October 2026. Named implementations are described from their maintainers’ documentation; I have not independently run or benchmarked them.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;a href="https://github.com/rehan-remade/universal-modder#built-with-it" rel="noopener noreferrer"&gt;Universal Modder: documented Minecraft × GTA V example&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://github.com/morluto/rea#how-rea-works" rel="noopener noreferrer"&gt;REA: overview and how it works&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://github.com/soulsmods/ModEngine2" rel="noopener noreferrer"&gt;Mod Engine 2: runtime patching, launcher and extension documentation&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://docs.godotengine.org/en/stable/tutorials/physics/physics_introduction.html" rel="noopener noreferrer"&gt;Godot documentation: collision shapes, physics bodies and collision response&lt;/a&gt;. General collision concepts; not evidence of a particular Halo mod implementation.&lt;/li&gt;
&lt;/ol&gt;

</description>
      <category>ai</category>
      <category>gamedev</category>
      <category>architecture</category>
      <category>programming</category>
    </item>
    <item>
      <title>Ship a Lambda Web Function with CDK</title>
      <dc:creator>Sean Boult</dc:creator>
      <pubDate>Wed, 28 Oct 2026 17:45:51 +0000</pubDate>
      <link>https://dev.to/aws/ship-a-lambda-web-function-with-cdk-16na</link>
      <guid>https://dev.to/aws/ship-a-lambda-web-function-with-cdk-16na</guid>
      <description>&lt;p&gt;So, &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/web-functions.html" rel="noopener noreferrer"&gt;AWS Lambda Web Functions&lt;/a&gt; just came out, and I'm super excited about them.&lt;/p&gt;

&lt;p&gt;What are they? Well, you can now ship Express, Hono, or React Router with no Lambda-specific adapters or wrappers.&lt;/p&gt;

&lt;p&gt;Let me show you how I got this demo set up with CDK.&lt;/p&gt;

&lt;p&gt;λ: &lt;a href="https://cxrj1w1j65n0k7ss.p7v.lambda-web.us-east-2.on.aws" rel="noopener noreferrer"&gt;https://cxrj1w1j65n0k7ss.p7v.lambda-web.us-east-2.on.aws&lt;/a&gt; (this may not live forever but the code should)&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;⚠️ &lt;strong&gt;DISCLAIMER&lt;/strong&gt;: The code we are about to see is written with L1 CDK constructs. The L2 constructs are being tracked via &lt;a href="https://github.com/aws/aws-cdk/pull/39210" rel="noopener noreferrer"&gt;this PR&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;First, let's look at the server code I have in Express. I've omitted the bulk of its logic for brevity.&lt;/p&gt;

&lt;p&gt;Here, you can see that it's an &lt;a href="https://expressjs.com/" rel="noopener noreferrer"&gt;Express.js&lt;/a&gt; server binding to a port.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nx"&gt;express&lt;/span&gt; &lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;express&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;hostname&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;rawPort&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;
  &lt;span class="nx"&gt;process&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;env&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;AWS_LAMBDA_HTTP_ENDPOINT&lt;/span&gt; &lt;span class="o"&gt;??&lt;/span&gt;
  &lt;span class="s2"&gt;`127.0.0.1:&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;process&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;env&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;PORT&lt;/span&gt; &lt;span class="o"&gt;??&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;3000&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;`&lt;/span&gt;
&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;:&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;port&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Number&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;rawPort&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;

&lt;span class="k"&gt;export&lt;/span&gt; &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;app&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;express&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;

&lt;span class="k"&gt;export&lt;/span&gt; &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;server&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;app&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;listen&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;port&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;hostname&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;`Spinning Lambda is listening on http://&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;hostname&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;:&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;port&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;`&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;I can run the code locally with &lt;code&gt;pnpm dev&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5u9ymzdams5ypv2bkrs9.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5u9ymzdams5ypv2bkrs9.png" alt=" " width="800" height="663"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Now, let's look at the CDK stack used to deploy this function.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="k"&gt;export&lt;/span&gt; &lt;span class="kd"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;SpinningLambdaStack&lt;/span&gt; &lt;span class="kd"&gt;extends&lt;/span&gt; &lt;span class="nc"&gt;Stack&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nf"&gt;constructor&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;scope&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;Construct&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;id&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kr"&gt;string&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;props&lt;/span&gt;&lt;span class="p"&gt;?:&lt;/span&gt; &lt;span class="nx"&gt;StackProps&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;super&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;scope&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;props&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;

    &lt;span class="c1"&gt;// code bucket stuff omitted&lt;/span&gt;
    &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;webFunction&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;CfnWebFunction&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;this&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;WebFunction&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="na"&gt;functionName&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;`&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="k"&gt;this&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;stackName&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;-web`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="c1"&gt;// many props omitted for brevity&lt;/span&gt;
    &lt;span class="p"&gt;});&lt;/span&gt;

    &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;revision&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;CfnWebFunctionRevision&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;this&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;WebFunctionRevision&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="na"&gt;functionName&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;webFunction&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;ref&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="c1"&gt;// many props omitted for brevity&lt;/span&gt;
    &lt;span class="p"&gt;});&lt;/span&gt;

    &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;endpoint&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;CfnWebFunctionEndpoint&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;this&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;WebFunctionEndpoint&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="na"&gt;functionName&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;webFunction&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;ref&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="c1"&gt;// many props omitted for brevity&lt;/span&gt;
    &lt;span class="p"&gt;});&lt;/span&gt;

  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Now for deployment. I'm using the &lt;a href="https://aws.amazon.com/blogs/aws/aws-reimagines-the-getting-started-experience/" rel="noopener noreferrer"&gt;new AWS experience&lt;/a&gt;, so I have a &lt;a href="https://docs.aws.amazon.com/accounts/latest/reference/create-project.html" rel="noopener noreferrer"&gt;project&lt;/a&gt; dedicated to this demo.&lt;/p&gt;

&lt;p&gt;I grab some credentials for my account with &lt;code&gt;aws login&lt;/code&gt;. I need to do a one-time setup to bootstrap CDK with &lt;code&gt;npx cdk bootstrap&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Once that's done, I can run &lt;code&gt;pnpm deploy&lt;/code&gt; to ship it.&lt;/p&gt;

&lt;p&gt;Then it's live 🚀!&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fs1tjdtg03c95f8zx7ci8.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fs1tjdtg03c95f8zx7ci8.png" alt=" " width="800" height="673"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Share this on X/Twitter, and it should render as an embed:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;https://cxrj1w1j65n0k7ss.p7v.lambda-web.us-east-2.on.aws/embed

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Full repo:&lt;br&gt;
&lt;a href="https://github.com/sboult/lwf-three-js" rel="noopener noreferrer"&gt;https://github.com/sboult/lwf-three-js&lt;/a&gt;&lt;/p&gt;



&lt;p&gt;As always, happy coding 😉!&lt;/p&gt;

&lt;p&gt;Follow AWS for more articles like this.&lt;/p&gt;


&lt;div class="ltag__user ltag__user__id__1726"&gt;
  &lt;a href="/aws" class="ltag__user__link profile-image-link"&gt;
    &lt;div class="ltag__user__pic"&gt;
      &lt;img src="https://media2.dev.to/dynamic/image/width=150,height=150,fit=cover,gravity=auto,format=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Forganization%2Fprofile_image%2F1726%2F2a73f1e6-7995-4348-ae37-44b064274c59.png" alt="aws image"&gt;
    &lt;/div&gt;
  &lt;/a&gt;
  &lt;div class="ltag__user__content"&gt;
    &lt;h2&gt;
      &lt;a href="/aws" class="ltag__user__link"&gt;AWS&lt;/a&gt;
      Follow
    &lt;/h2&gt;
    &lt;div class="ltag__user__summary"&gt;
      &lt;a href="/aws" class="ltag__user__link"&gt;
        Articles written by current and past AWS Developer Advocates to help people interested in building on AWS. Opinions are each author's own.
      &lt;/a&gt;
    &lt;/div&gt;
  &lt;/div&gt;
&lt;/div&gt;



&lt;p&gt;Follow me for all things tech!&lt;/p&gt;


&lt;div class="ltag__user ltag__user__id__828306"&gt;
    &lt;a href="/hacksore" class="ltag__user__link profile-image-link"&gt;
      &lt;div class="ltag__user__pic"&gt;
        &lt;img src="https://media2.dev.to/dynamic/image/width=150,height=150,fit=cover,gravity=auto,format=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F828306%2Fbf0bbed7-7874-4a26-8137-bb761a4b7f23.png" alt="hacksore image"&gt;
      &lt;/div&gt;
    &lt;/a&gt;
  &lt;div class="ltag__user__content"&gt;
    &lt;h2&gt;
&lt;a class="ltag__user__link" href="/hacksore"&gt;Sean Boult&lt;/a&gt;Follow
&lt;/h2&gt;
    &lt;div class="ltag__user__summary"&gt;
      &lt;a class="ltag__user__link" href="/hacksore"&gt;Developer. Hacker. Creator.&lt;/a&gt;
    &lt;/div&gt;
  &lt;/div&gt;
&lt;/div&gt;


</description>
      <category>aws</category>
      <category>serverless</category>
      <category>express</category>
    </item>
  </channel>
</rss>
