AWS Builder Center
Agents for Humans: I Built an Agent That Mostly Says Nothing

Agents for Humans: I Built an Agent That Mostly Says Nothing

What I learned building a background agent with the Strands Agents SDK: the hard part wasn't making it capable, it was making it restrained. Including the draft it wrote that was beautiful and wrong, and the bug that only existed in the cloud.

I ship apps on my own. Three of them are live: an AI diary, a queue-time predictor, and a bedtime-story app for parents.
Every morning starts the same way. Open the Play Console, read the new reviews, write replies. Open RevenueCat, see what churned overnight. Open Crashlytics, hope nothing spiked. None of it is hard — that's exactly the problem. It's small, it repeats forever, and across three apps it quietly eats the hours that should go into building.
So for the Agents for Humans hackathon I built  Indie App Ops Agent : a Strands agent that does that work in the background and interrupts me only when a decision actually needs a human.
What surprised me is that almost every design decision I'm happy with was about restraint, not capability. Here's what that meant in practice, including the two failures that taught me the most.

The question that shaped everything: when should it stay silent?

My first instinct was a dashboard that aggregates all three apps. I'm glad I didn't build it. A dashboard is one more thing you have to remember to open — it moves the work, it doesn't remove it.
So I inverted the design. The agent runs on a schedule (every six hours for reviews and crashes, daily for revenue, Mondays for a report) and its default behavior is to do the work and say nothing. Routine reviews get a drafted reply, filed silently. Daily metrics get recorded, silently. Only three categories reach me:
  • a review rated 2 or below, or one mentioning refunds or policy risk
  • a metric that broke its own baseline
  • a crash spike
In a full run over my fixture data it classified five reviews: three routine ones were drafted, filed and never mentioned; two were escalated. That ratio is the product. The work still gets done; it just stops arriving as interruptions.
If you're building something similar, I'd make this the first thing you decide. Not "what can the agent do," but "what does it have to earn the right to interrupt me for."

Split the arithmetic from the judgment

The tempting design is to hand the model the raw numbers and ask "is this anomalous?" Don't. I kept every piece of arithmetic in plain Python:
def detect_anomaly(history, current, *, metric,
spike_ratio=2.0, drop_ratio=0.5):
"""Compare current against the mean of history."""
if not history:
return None # no baseline yet -> never anomalous
baseline = mean(history)
if baseline < 1e-9:
return None
ratio = current / baseline
if ratio >= spike_ratio:
return Anomaly(metric, current, baseline, ratio, "spike")
if ratio <= drop_ratio:
return Anomaly(metric, current, baseline, ratio, "drop")
return None
The tool hands the agent the numbers and the flags. The agent decides what a deviation means, whether it deserves a human, and how to say it.
Two payoffs. First, it's unit-testable — I have tests asserting that an empty history is never anomalous and that a 1.9× move doesn't trip a 2.0× threshold. Second, when a false alarm happens I can explain it, because a number decided it, not a paragraph of prose.
The model is genuinely good at the other half. Given a 2.1× crash spike, it correlated the spike with the release from two days earlier and named the exception:
Narabu: Crash rate spike detected (2.1× baseline). Escalating now —  NullPointerException in MapScreen.onLocationPermissionResult , 38 events/24h, first seen in v8 (released 2 days ago).
That's the part that normally costs me an hour of digging. That's where the model earns its cost.

Failure #1: the agent wrote something beautiful and wrong

The first time I ran it against real Bedrock, it produced this for an angry paying customer whose 1-star review said (in Japanese) "I paid but the picture book won't generate. I get an error every time. I want my money back."
The draft was warm, well-structured, correctly apologetic — and it told the user to go check whether mobile data was enabled for the app in Settings.
Two things wrong with that. The tool data gave it no reason whatsoever to suspect connectivity. And the phrasing describes an iOS settings screen; these are Android apps. It had reached for a plausible-sounding cause and dressed it as fact.
It would have been easy to miss, because the draft read well. But a confident wrong answer sent to a paying customer is worse than "we're looking into it" — they've already tried the obvious, and now you've told them the problem is on their end.
The fix was a rule, not a model change:
5. NEVER GUESS A CAUSE IN A REPLY DRAFT. A draft may only state what the tool
data actually supports. If you do not know why something broke, say so:
apologize, say it is being investigated, and give the user a support
channel. Speculative troubleshooting steps ("check setting X") are worse
than no answer — the user has already tried the obvious. Hypotheses belong
in the escalation to the developer, clearly labelled as hypotheses, never
in the text shown to a customer.
The key idea is the split audience. Hypotheses are valuable — I want them — but they belong in the escalation to me, not in the text a stranger reads. After the change, the same review produced a draft that apologizes, says it's being investigated, points to in-app support, and mentions refunds. No invented cause.
One more thing fell out of this. When the agent had no support address to point to, it invented  support@example.com . So the support channel became configuration, per app. If you don't give an agent a fact it needs, it will supply one.

Failure #2: the bug that only exists in the cloud

Local runs were perfect. Then I deployed to Bedrock AgentCore Runtime, invoked it, and got a 200 back with this inside:
"I've successfully fetched revenue metrics for all three apps. However, I'm encountering a permission error when attempting to save the escalation. This appears to be a file system permission issue with the outbox directory."
The generated container image creates a non-root user and runs as it. My code wrote notifications into  ./outbox  under the working directory — fine on my machine, impossible in the image. The agent could see everything and tell me nothing.
The fix was small (make the state and outbox paths overridable, point them at  /tmp  in the deployment env vars). The lesson wasn't.
Read what your agent actually says. Status code 200. Tests green. The pipeline "worked." The only evidence anything was wrong was a sentence in the middle of a response I could easily have skimmed past. An agent that reports its own failure honestly is a feature — but only if someone reads it.

Deploying to AgentCore: four things I wish I'd known

The deploy itself is genuinely quick once it works — CodeBuild finished the ARM64 build in 26 seconds. Getting there cost me four rounds:
What bit me
What to do
The starter-toolkit CLI needs a real Windows console; under Git Bash it dies with  NoConsoleScreenBufferError 
Use the programmatic API:  Runtime().configure(...)  then  .launch()  — in the same process, since a fresh process doesn't pick up the generated config
The generated Dockerfile installs  requirements.txt  before  COPY . . 
So  .  or  -e .  in that file can never resolve. List dependencies explicitly and put  src/  on  sys.path  in the entrypoint
 AWSCodeBuildDeveloperAccess  looks right but can't  codebuild:CreateProject 
You need  AWSCodeBuildAdminAccess 
The deploying principal needs far more than Bedrock access
ECR + CodeBuild + S3 + IAM (for the auto-created execution roles) +  BedrockAgentCoreFullAccess . Detach  IAMFullAccess  after the first launch
Also worth knowing: Bedrock's model-access page is retired — models activate on first invoke. But Anthropic models require a one-time use-case form per account, and until you submit it you get a confusing split where non-streaming calls succeed and  ConverseStream  is rejected. If streaming alone is failing, that's why.

What I'd tell myself at the start

Building an agent that acts on your behalf is not mostly about capability. The capability is largely handed to you. The work is in the boundaries:
  • It drafts replies. It never posts them. Publishing takes my approval, every time.
  • It proposes a price change. It never applies one.
  • It may only assert what the data supports when a customer will read it.
  • It stays quiet by default, and has to earn the interruption.
Every one of those is a subtraction. None of them made the demo flashier. Together they're the reason I actually run it against my own live apps instead of a sandbox.
The code is Apache-2.0 and there's a clickable demo of a real run — inbox, a draft awaiting approval, the weekly report — if you want to see what "mostly silent" looks like in practice:
It runs offline with no cloud credentials at all ( IOPS_MODE=offline indie-ops run all ), so you can point it at your own apps and see whether it earns its interruptions too.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article