
Weekend Showcase Challenge: Hermes Agent
A summer build exploring planning, execution, memory, and tool use in an AI agent, deployed on AWS with Lambda, SAM, API Gateway, and Amazon Bedrock Nova 2 Lite.
Hermes Agent Assistant: Building and Deploying a Tool-Using AI Agent on AWS
This summer, I wanted to move beyond building another simple chatbot and explore what it actually takes to build an AI agent that can understand a goal, create a plan, execute actions, use tools, maintain memory, and produce a useful response.
That idea became Hermes Agent Assistant — a Python-based tool-using AI agent built around a planner, executor, memory system, and Amazon Bedrock integration.
For the Summer Builds Showcase, I took Hermes beyond the local development stage and deployed it on AWS using AWS Lambda, Amazon API Gateway, AWS SAM, AWS CloudFormation, IAM, and Amazon Bedrock.
What I Built
Hermes is based on a simple idea: an agent should do more than immediately send a prompt to a language model.
When Hermes receives a task, it first creates a plan, determines the steps required, executes the workflow, keeps useful information in memory, and then generates a final response.
The core architecture contains three main components:
- Planner — breaks the user's task into actionable steps.
- Executor — coordinates the workflow and available tools.
- Memory — stores useful information generated during interactions.
I also created a Bedrock service layer that allows Hermes to send the original task, generated plan, and tool results to Amazon Nova 2 Lite through Amazon Bedrock.
The goal was not to create the largest possible agent framework. I wanted to understand the complete lifecycle of an AI agent: architecture, model integration, packaging, permissions, deployment, runtime debugging, and cloud execution.
Why Hermes?
While working on AI projects this summer, I became increasingly interested in the difference between a chatbot and an agent.
A chatbot can answer a question.
An agent can receive a goal and determine what needs to happen next.
That distinction motivated Hermes.
Instead of simply calling an LLM and displaying its output, I wanted the structure of the application itself to demonstrate agent-like behavior.
The flow became:
Task → Planner → Executor → Tools / Memory → Amazon Bedrock → Final Response
Keeping these responsibilities separated also made the code easier to understand, test, and extend.
Bringing Hermes to AWS
For the Builder Showcase, I decided to take Hermes from a local Python project to a real AWS deployment.
I created an AWS SAM template defining the Hermes Lambda function, Python runtime, IAM permissions, environment variables, and an HTTP API endpoint.
The final deployed architecture is:
User → Amazon API Gateway → AWS Lambda → Hermes Planner / Executor / Memory → Amazon Bedrock Nova 2 Lite
Hermes is deployed in the AWS
ap-southeast-2 region.The application uses Python 3.13 on AWS Lambda and is configured to access Amazon Nova 2 Lite using the active global inference profile:
global.amazon.nova-2-lite-v1:0 I validated and packaged the application using AWS SAM:
-
sam validate— successful
-
sam build— successful
-
sam deploy— successful
- AWS CloudFormation stack — successfully created
- AWS Lambda function — successfully deployed
- Amazon API Gateway HTTP API — successfully created
- IAM execution permissions — configured
- Nova 2 Lite inference profile — confirmed active
The CloudFormation stack successfully created the Lambda function, IAM execution role, API Gateway HTTP API, Lambda invocation permissions, and API stage.
Hermes is now running as a real cloud-deployed application rather than only as a local prototype.
What Broke Along the Way
The most useful part of this project was often what did not work the first time.
Python Runtime Compatibility
My first SAM build failed because the CloudShell environment had Python 3.13 while the original SAM template specified Python 3.12.
I updated the Lambda runtime to Python 3.13 and rebuilt the project.
After that, AWS SAM successfully resolved the dependencies and generated the deployment artifacts.
AWS Organization Policy Restrictions
My next problem was more complicated.
When I initially tried deploying in
us-east-1 , AWS CloudFormation returned an AccessDenied error because an AWS Organizations Service Control Policy explicitly denied CloudFormation operations.Direct Lambda operations in that region were also blocked by the same organization-level policy.
This was an important lesson because the problem was not in the Hermes code and could not be solved by simply adding another IAM permission.
An explicit Service Control Policy deny operates above normal IAM permissions.
Instead of continuing to change application code for an account-level restriction, I tested the deployment in
ap-southeast-2 .The required Lambda and CloudFormation operations were permitted there, and Hermes successfully deployed.
Amazon Nova 2 Lite Inference Profiles
I also encountered a Bedrock-specific issue.
Calling the Nova 2 Lite base model directly produced an error because on-demand invocation required an inference profile.
I inspected the available Amazon Bedrock inference profiles and updated Hermes to use:
global.amazon.nova-2-lite-v1:0 The profile was confirmed as active and the application now uses it through the Bedrock runtime integration.
During final testing, Bedrock model invocation was temporarily affected by account verification and throttling limits. Instead of allowing that service-level condition to crash the entire application, Hermes catches the Bedrock exception and returns a graceful fallback response.
Lambda's Read-Only File System
After the first successful cloud deployment, I tested the live Hermes HTTP API and discovered another problem.
The agent returned:
[Errno 30] Read-only file system: 'memory.json' Hermes originally stored its lightweight memory in a local
memory.json file. That worked locally, but an AWS Lambda deployment package is read-only at runtime.I changed Hermes to store temporary runtime memory inside Lambda's writable
/tmp directory.After rebuilding and redeploying the application, the error disappeared.
The live API then successfully executed the Hermes workflow and returned its generated plan.
For example, when I asked Hermes to create a plan for learning AWS Lambda, the deployed agent successfully returned the task and planned execution steps while gracefully reporting the temporary Bedrock throttling condition.
That debugging step was especially useful because it highlighted the difference between code that works locally and code that works inside a serverless runtime.
AWS Architecture Overview
The final architecture can be summarized as:
User Request
↓
Amazon API Gateway HTTP API
↓
AWS Lambda — Hermes Agent Assistant
↓
Planner → Executor → Tools → Memory
↓
Amazon Bedrock
↓
Amazon Nova 2 Lite
AWS SAM defines the serverless application, while AWS CloudFormation provisions and manages the underlying resources.
IAM provides the Lambda execution permissions required for logging and Amazon Bedrock access.
This architecture keeps Hermes relatively small while still demonstrating the complete path from user request to agent planning, execution, cloud hosting, and model integration.
What I Learned
Hermes started as an experiment in agent architecture, but it became a much broader lesson in building and deploying AI applications on AWS.
Across the project, I learned how to:
- Structure an AI agent around planning, execution, tools, and memory.
- Separate agent responsibilities into understandable Python modules.
- Integrate Amazon Bedrock into an application.
- Work with Amazon Nova 2 Lite inference profiles.
- Package serverless applications using AWS SAM.
- Deploy Python applications to AWS Lambda.
- Expose Lambda through an Amazon API Gateway HTTP endpoint.
- Configure IAM execution permissions.
- Use AWS CloudFormation through SAM deployments.
- Diagnose AWS Organizations Service Control Policy restrictions.
- Distinguish application errors from account-level AWS restrictions.
- Debug differences between local filesystems and Lambda runtime environments.
- Handle external AI service failures gracefully rather than crashing an entire application.
Most importantly, I learned that getting an AI application into the cloud involves much more than writing the agent logic.
Runtime compatibility, IAM permissions, model availability, inference profiles, regional restrictions, account verification, quotas, serverless filesystem behavior, and deployment infrastructure all become part of the engineering problem.
The failures were not separate from the project.
They became part of what made the project useful.
What's Next
Hermes is now deployed on AWS Lambda and accessible through an Amazon API Gateway HTTP API.
The next step is completing uninterrupted Amazon Bedrock inference testing once the account-level verification and throttling limits are cleared.
I also want to improve Hermes by replacing the temporary
/tmp memory implementation with persistent cloud storage, expanding the available tools, adding stronger observability and logging, and experimenting with more autonomous workflows.The current
/tmp implementation works for Lambda runtime execution, but it is intentionally lightweight and is not intended to provide permanent memory across every Lambda instance. Persistent agent memory is therefore one of the most interesting improvements I can make next.For me, the Summer Builds Showcase became less about presenting a perfect project and more about showing the complete progression from an idea to a deployed system.
Hermes began as a Python agent architecture.
It ended the summer as an agent running on AWS Lambda behind an HTTP API, integrated with Amazon Bedrock, packaged with AWS SAM, managed through CloudFormation, and improved through several real cloud debugging challenges.
That's what made building Hermes worthwhile.
And finally, thank you to the builders in the community who shared projects, experiments, and ideas throughout the summer. Seeing what other builders were creating encouraged me to continue experimenting and take Hermes further.
A special thanks to Ajay Kumar Yegireddi (@se7enaj) for inspiring me through the AWS Builder community and encouraging me to keep learning, experimenting, and pushing my projects further throughout the summer.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article