AWS Builder Center

Weekend Creative Agent Challenge: Building an Always-On Severless Creative Agent: A Journey of Resilience and a Beginner's Mindset on AWS #Agenthourlytrigger

A beginner's journey into building an always-on, serverless AI creative agent on AWS—combining automation, persistent memory, resilience, and an evolutionary creative workflow while learning cloud architecture through real-world challenges. #agents

Introduction
This weekend, I jumped into the AWS Weekend Challenge (Level 200) to build an autonomous, always-on creative agent. My goal was simple: design a system that works on its own when the user is away, evolves its style over time, and demonstrates a modern cloud architecture.
As a new developer who created my AWS account just last night, this project was a massive learning milestone. Approaching this with a beginner's mindset meant that every hurdle became a lesson. Instead of letting restrictions stop me, I used architectural patterns to build a resilient, production-ready system that is fully prepared for scale.


Navigating New Account Restrictions: The Bedrock Fraud Sandbox
When a developer spins up a brand-new AWS account, the platform applies hidden security guardrails to protect against fraud and runaway costs. High-compute Generative AI services like Amazon Bedrock are heavily restricted.
During my first deployment testing with the new Amazon Nova Micro model, I was met with hard backend blocks: a ValidationException followed by an AccessDeniedException stating that my account was undergoing verification. Because I initially signed up using a UPI AutoPay mandate, the automated risk engine required extra verification before unlocking the AI data planes.
To navigate this like a true cloud engineer, I took immediate corrective actions:
  1. Moved Away from the Root User: I created a dedicated IAM user named  inboxpilot-dev  with specific programmatic and console access permissions, ensuring best-practice security.
  1. Upgraded the Billing Profile: I linked a global debit card alongside my UPI mandate to pass secondary identity verification checks.
  1. Opened an AWS Support Ticket: I formally requested a manual review to lift the Bedrock invocation restrictions.
Because the challenge deadline was fast approaching, I could not wait 24 hours for the support team to clear the backend sync. I had to pivot and innovate.


Architectural Breakdown: Designing for High Resilience

┌─────────────────────┐
│ EventBridge │
│ Scheduled Trigger │
└──────────┬──────────┘
│
▼
┌────────────────────────────────────────────────┐
│ AWS LAMBDA │
│ │
│ Creative Poet Agent │
│ │
│ 1. Retrieve memory │
│ 2. Build evolutionary prompt │
│ 3. Invoke AI │
│ 4. Handle failures │
│ 5. Update memory │
└───────────────┬────────────────┬───────────────┘
│ │
│ │
Read / Write Retrieve Secret
│ │
▼ ▼
┌──────────────┐ ┌─────────────────┐
│ DynamoDB │ │ Secrets Manager │
│ │ │ │
│ AgentMemory │ │ Groq API Key │
└──────────────┘ └────────┬────────┘
│
▼
┌────────────────────────────────┐
│ AI PROVIDERS │
│ │
│ PRIMARY │
│ Amazon Bedrock │
│ │ │
│ Failure │
│ ▼ │
│ SECONDARY │
│ Groq GPT-OSS 20B │
│ │ │
│ Failure │
│ ▼ │
│ LOCAL FALLBACK │
│ Random poem pool │
└───────────────┬────────────────┘
│
▼
Generated Output
│
▼
DynamoDB Update
┌─────────────────────────────┐
│ HTML Frontend │
│ Dark-themed UI │
└──────────────┬──────────────┘
│
▼
Lambda Function URL
│
▼
AWS Lambda

The Component Workflow

  • Trigger Mechanism: Amazon EventBridge acts as the agent's digital alarm clock, automatically invoking the AWS Lambda function on a recurring schedule.
  • Agent Engine: AWS Lambda runs the core Creative Poet Agent logic. It retrieves the agent's previous memory, builds an evolutionary prompt, manages AI invocation, handles failures, and saves the new state.
  • Persistent Memory: Amazon DynamoDB stores the agent's  AgentMemory , including its artistic style profile, latest output, and execution history. Each run uses this information to influence the next generation.
  • Primary AI Engine: Amazon Bedrock serves as the first AI provider. The Lambda function attempts to generate the poem through the configured Bedrock model.
  • Secondary AI Engine: If Bedrock is unavailable or the invocation fails, the agent automatically switches to Groq using the GPT-OSS 20B model. The Groq API key is securely retrieved from AWS Secrets Manager rather than being stored in the source code.
  • Fail-Safe Layer: If both Bedrock and Groq fail, the Lambda activates a local fallback pool and randomly selects a pre-written poem. This ensures the agent can still complete its execution without an external AI service.
  • State Update: After generation, the Lambda stores the new poem and updated artistic style profile back in DynamoDB, creating a persistent creative feedback loop for future executions.
  • Presentation Layer: A custom dark-themed HTML frontend connects through the Lambda Function URL, providing a public interface to manually wake and test the agent in addition to its automated EventBridge execution.



Lessons Learned & The Beginner Mindset

Building this project taught me that cloud development is rarely a straight line from code to deployment. It is about understanding how services interact, designing for failure, and continuously improving the system as new challenges appear.
Throughout the project, I encountered issues across the stack — from Lambda execution and HTTP requests to model access, permissions, and runtime behavior. Each roadblock became an opportunity to better understand how serverless components communicate and how to design an application that remains reliable when individual services are unavailable.
One of the biggest lessons was the importance of resilience and graceful failure. Rather than allowing the agent to stop when its AI service was temporarily unavailable, I designed the Lambda workflow to handle failures safely and continue through a controlled fallback path. This keeps the core automation loop independent from any single model invocation.
I also learned that persistence is what gives a serverless function a sense of continuity. By storing the agent's evolving artistic profile in DynamoDB, every execution can build upon previous activity instead of starting from scratch.
Most importantly, embracing a beginner mindset helped me treat every error as part of the learning process. Instead of stopping when certain AWS capabilities were still being configured or verified, I adapted the architecture while keeping the core challenge requirements intact.
The final result is a serverless, stateful, resilient AI agent built around AWS services — capable of running automatically, maintaining persistent memory, handling failures gracefully, and evolving its behavior over time.



Try it



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