AWS Builder Center
I Built ReachAI: An Evidence-Driven AI Sales Assistant with Strands and Amazon Bedrock

I Built ReachAI: An Evidence-Driven AI Sales Assistant with Strands and Amazon Bedrock

I built ReachAI during a hackathon to solve a problem I kept seeing in outbound sales: AI can write personalized emails quickly, but it is much harder to know why an email should be trusted. Here is how I used Strands Agents, Amazon Bedrock, and AWS Amplify to build a human-in-the-loop outbound sales workflow.

I Built ReachAI: An Evidence-Driven AI Sales Assistant with Strands and Amazon Bedrock

I wanted to build something around AI and sales for a hackathon, but I didn't want to make another tool that simply takes a person's name and generates an email.
That part is easy.
The question I kept coming back to was:
Why should a salesperson trust the email the AI just wrote?
An AI can generate a good-looking email in a few seconds. But when someone reads it, they should still be able to understand where the personalization came from.
That idea became ReachAI.
ReachAI is an AI-powered outbound sales assistant that takes prospect and company context, identifies a relevant business opportunity, creates a personalization angle, and generates an outreach sequence.
The important part is that it also shows the evidence behind the personalization.



What ReachAI actually does

The workflow I ended up building is:
Prospect context
↓
Business opportunity
↓
Personalization angle
↓
Why This Message?
↓
Personalized email
↓
Day 3 follow-up
↓
Day 7 follow-up
↓
Review → Edit → Regenerate → Approve
For the demo, I used a fictional prospect:
Rahul Sharma VP Sales at Acme Technologies
Acme is described as a B2B SaaS company that provides workflow automation software and is expanding its sales organization.
ReachAI uses that information to build the campaign rather than inventing random personal details.
The result isn't just an email.
The salesperson can also see why the system chose that angle.



The idea behind “Why This Message?”

This became my favorite part of the project.
I didn't want to expose the model's private reasoning or show some giant block of AI-generated explanation.
Instead, ReachAI shows the business evidence used for the personalization.
For example:
Evidence: Acme is expanding its sales organization.
From that, the system can create a relevant business angle around sales growth, outbound capacity, or scaling the sales process.
That sounds simple, but it changed how I thought about the product.
The AI isn't just saying:
“This is a personalized email.”
It is also answering:
“What information made this personalization relevant?”
That makes the salesperson part of the decision instead of asking them to blindly trust the generated output.



Building the AI agent

For the agent workflow, I used the open-source Strands Agents SDK.
The basic idea is that the agent receives the task, can access the prospect context through a tool, and then generates the campaign.
A simplified version of the setup looks like this:
import { Agent, FunctionTool } from "@strands-agents/sdk";
import { BedrockModel } from "@strands-agents/sdk/models/bedrock";

const model = new BedrockModel({
region: "ap-south-1",
modelId: process.env.BEDROCK_MODEL_ID ?? "apac.amazon.nova-micro-v1:0",
maxTokens: 1800,
temperature: 0.35,
});

const agent = new Agent({
model,
systemPrompt,
tools: [getProspectContextTool],
});
I also created a custom tool for retrieving the supplied prospect context.
const getProspectContextTool = new FunctionTool({
name: "get_prospect_context",
description: "Retrieve the supplied prospect and company context.",
inputSchema: {
type: "object",
properties: {
prospectId: {
type: "string",
},
},
required: ["prospectId"],
},
callback: async ({ prospectId }) => {
return getProspectContext(prospectId);
},
});
The reason I wanted the context retrieval to be a tool was straightforward: I wanted the model to work from actual supplied context rather than relying on whatever information it might assume.



Keeping the AI grounded

One thing I was careful about was hallucinated personalization.
It would be very easy to make the demo look impressive by giving the model vague instructions like:
“Research this person and write a highly personalized email.”
But that creates a problem.
The model might start making assumptions about the prospect.
For ReachAI, the instruction is much more restrictive:
  • Use the supplied prospect and company context.
  • Never invent facts.
  • Never claim unsupported personal information.
  • Focus on business relevance.
  • Keep the personalization tied to evidence.
This is also why the current demo deliberately uses fictional prospect data.
I wanted to test the product workflow without pretending that I had real people's private information.



Why I kept a human in the loop

At one point, I considered making the workflow more automated.
But the more I thought about it, the less I liked the idea of an AI system automatically sending sales emails.
So I kept the final step with the salesperson.
The workflow became:
Generate → Review → Edit → Regenerate → Approve
The user can inspect the email, make changes, ask for another version, or approve it.
I think this is a better fit for the product because AI handles the repetitive work while the human still controls the final message.



Generating the follow-ups

ReachAI generates the initial email and two follow-ups.
I deliberately kept this simple:
Day 0 → Initial email
Day 3 → Follow-up
Day 7 → Follow-up
I didn't try to build a complete sales engagement platform with scheduling, CRM integrations, LinkedIn scraping, and dozens of automation rules.
That would have made the project much larger without helping me prove the core idea.
For this MVP, I wanted to answer one question:
Can AI help create personalized outbound while still showing the human why the message makes sense?



The part that took more time than expected: AWS

Getting the local application working was only half the job.
Deploying it introduced a completely different set of problems.
I had to deal with things like:
  • Bedrock model and inference-profile configuration
  • IAM permissions
  • AWS region/model availability
  • Amplify's supported Next.js version
  • GitHub integration
  • production environment variables
The Bedrock configuration was particularly confusing at first because the model identifier I wanted to use was tied to an inference profile.
That meant I had to understand the difference between simply choosing a model and invoking it through the correct inference profile in the region I was using.
Eventually, I configured ReachAI around the Amazon Nova Micro inference profile:
apac.amazon.nova-micro-v1:0
in the Mumbai region:
ap-south-1
That was one of those problems that looks small in documentation but can take a while to understand when you are building everything for the first time.



Deploying with AWS Amplify

For the production deployment, I used AWS Amplify Hosting.
The final architecture looks like this:
User
│
▼
Next.js Application
│
▼
AWS Amplify Hosting
│
▼
Strands Agent
│
├── Prospect Context Tool
│
▼
Amazon Bedrock
│
▼
Amazon Nova Micro
│
▼
Structured Campaign
I also created an IAM compute role for the deployed application so the production app could invoke Bedrock without putting AWS credentials inside the application code.
That was important to me because the local setup and production setup should not depend on hardcoded credentials.



A deployment issue I didn't expect

I initially built the application with a newer Next.js version.
That worked locally.
Then I discovered that the version I was using wasn't the right fit for the Amplify deployment environment I was targeting.
So I ended up moving the project to a supported Next.js version and fixing the resulting TypeScript/build differences.
This was probably one of the less glamorous parts of the hackathon.
It wasn't part of the original product idea at all, but it was necessary to get from:
“It works on my laptop.”
to:
“There is an actual deployed application.”
That distinction matters more than I expected.



What I learned from building this

The biggest thing I learned wasn't actually about generating AI emails.
I learned that trust has to be part of the product design.
It is easy to ask an LLM to generate something.
It is harder to design what the human should see before deciding whether to use that output.
That is why the “Why This Message?” section became such an important part of ReachAI.
I also learned that the model is only one part of an AI application.
The actual product involves:
UI
+
Agent workflow
+
Tools
+
Model
+
Structured output
+
Human review
+
Deployment
And all of those parts have to work together.



What I would improve next

There are still plenty of things I would add if I continued building ReachAI.
The current version intentionally avoids turning into a full CRM or sales platform.
The next stage could include real prospect imports, CRM integrations, better company research, campaign performance tracking, and eventually real email delivery.
I would also like to experiment with better ways of presenting evidence so that the salesperson can understand the personalization without having to read through unnecessary AI-generated text.



Final architecture

The final version of ReachAI can be summarized like this:
┌──────────────────────┐
│ ReachAI UI │
│ Next.js │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ Strands Agent │
└──────────┬───────────┘
│
┌──────────────┴──────────────┐
│ │
▼ ▼
┌──────────────────┐ ┌──────────────────┐
│ Prospect Context │ │ Amazon Bedrock │
│ Tool │ │ Nova Micro │
└──────────────────┘ └────────┬─────────┘
│
▼
┌────────────────────────┐
│ Personalized Campaign │
│ + Evidence + Followups │
└────────────┬───────────┘
│
▼
┌────────────────────────┐
│ Human Review / Approval │
└────────────────────────┘



Final thoughts

When I started this project, I thought the interesting part would be making an AI generate a personalized sales email.
After building it, I don't think that's the interesting part anymore.
The interesting part is deciding how much control to give the AI and how much context to give the human.
That is what led me to ReachAI.
The AI does the repetitive work.
The salesperson still gets the final say.
And before they approve the message, they can see why the message was written that way.
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