Shoulda

Your financial “Should I…?” companion

Comment

Inspiration

The spark for Shoulda came from seeing how often people face life-changing financial choices — “Should I buy a house or keep renting?”, “Should I expand my business now or wait?” — with little more than gut feeling to guide them.

With the advent of coding agents, I experienced firsthand the power of agentic AI: systems that plan, reason, and act with autonomy. That convinced me this approach will diffuse far beyond coding, into domains like economics where clear, data-driven guidance is sorely needed.

Shoulda is my way of taking that insight into action — building an agent that turns public market data into simple, trustworthy answers to everyday “Should I…?” questions.

What it does

Shoulda is an AI agent that answers everyday “Should I…?” economic questions with clear, data-backed insights.

A user can ask:

  • “Should I buy a house or keep renting?”
  • “Should I expand my restaurant now or wait?”
  • “Should I switch jobs in this market?”

Behind the scenes, the Conductor agent plans the reasoning steps, then delegates to a Data Fetcher agent that pulls live data from FRED, Yahoo Finance, and CME futures. The system analyzes trends, compares scenarios, and streams back a plain-English recommendation with supporting context.

How we built it

We built Shoulda as two cooperating Bedrock AgentCore runtimes:

  • Conductor agent – orchestrates reasoning, manages memory, and streams live status updates. It also calls multiple Data Fetcher subtasks in parallel. Parallelization reduces latency and helps the agent deliver answers faster.

  • Data Fetcher agent – handles structured subtasks for pulling data from FRED, Yahoo Finance, and CME futures.

On top of that, we used:

  • AWS Nova Premier model – the core LLM powering reasoning and natural language generation.
  • AWS Strands framework – to implement agents and tool integrations in a structured, reliable way.

The Conductor leverages AWS AgentCore memory for short-term recall, letting each session build on prior turns.

The infrastructure runs fully on AWS:

  • Lambda + CloudFront proxy streams Server-Sent Events to the frontend.
  • Cognito secures API access.
  • Next.js frontend provides the chat interface with real-time agent status.

We started with a local MVP where Conductor and Data Fetcher ran in one process, then evolved them into independent runtimes for seamless AWS deployment.

Challenges we ran into

  • Balancing local vs. AWS environments – For fast iteration, I wanted to run as much as possible locally. The result is that most services — including AgentCore and mock memory — run fully on my laptop, with only the LLM staying remote. This sped up development but also made it challenging to keep behavior consistent with the AWS deployment.
  • Stochastic LLM behavior – The Nova Premier model sometimes produced varied outputs that broke downstream parsing. I had to apply prompt engineering and defensive parsing to tame responses and keep the pipeline stable.
  • Real-time streaming in AWS – Getting Server-Sent Events (SSE) working through Lambda, CloudFront, and the frontend was especially tricky. Small issues in headers or proxy settings could completely break streaming, so debugging required deep tracing across the entire AWS stack.

Accomplishments that we're proud of

  • AWS + AgentCore starter template – The project now serves as a practical template for anyone new to AWS or AgentCore, covering the essentials: authentication, agent orchestration, and real-time status streaming to the UI — all with a cost-efficient stack.
  • Seamless local + cloud workflow – Built a setup where almost everything runs locally (with only the LLM remote) for fast iteration, yet the same codebase deploys cleanly to AWS.
  • Real-time orchestration demo – Delivered an interactive experience with Server-Sent Events streaming agent progress end-to-end, making the system transparent and demo-ready.

What we learned

  • Invest early in production – I learned that setting up deployment and AWS infrastructure early, even when the project was just a skeleton, paid off later. It was difficult at the start, but once in place, I could focus on business logic and UI instead of fighting deployment issues.
  • LLM guardrails are essential – I also learned that even a strong model like Nova Premier needs prompt engineering and defensive parsing. Guardrails turned stochastic outputs into reliable, structured responses that the agent and UI could actually use.

What's next for Shoulda

  • Code interpreter in AgentCore – I explored the idea of using the code interpreter functionality during the hackathon, but it was hard to tame under time pressure. This is a powerful next step: giving agents access to a coding environment opens up new data sources and analytical capabilities.
  • Long-term memory – Extend from short-term to long-term memory in AgentCore, so the agent can build continuity across sessions and evolve recommendations over time.
  • SageMaker integration – Add AWS SageMaker for prediction modeling and validation. This would let Shoulda not only pull and analyze historical data but also run predictive models to forecast outcomes and test scenarios.

Built With

Share this project:

Updates