Inspiration

The challenge asked for an agentic tool that helps with an investment decision, explains what it checked, and adapts to a fictional investor. We picked a question that real analysts ask every day: when a sanction, a regulation, a tariff or a macro shock hits the news, which of my holdings are actually exposed, and how do I prove it? Impact rarely stops at the company named in the headline. It travels through suppliers, materials and customers, like a ripple. That is where the name RiskRipple comes from: it started as a "trickle-down" investigation agent, and we built it into the core of PolyFinances AlphaForge.

What it does

PolyFinances AlphaForge: RiskRipple is a multi-agent compliance watch for a portfolio.

  • Watches public regulatory, sanctions, macro and news feeds, and checks each new document against every saved portfolio.
  • Investigates with specialist agents (a regulatory watchdog, a regulatory investigator, an exposure and contagion mapper, and a ripple investigator). They trace the path from an event to a company, then to the portfolio, and report the exposure as a portfolio weight instead of an invented dollar loss.
  • Adapts to the fictional personas of the challenge (Amira, Mateo and Robert): the same facts, a different reading depending on their risk, horizon and preferences.
  • Explains every result. Each figure comes with its source and date. Weights, concentration, sector exposure, volatility and drawdowns are computed by plain code, and the language model only chooses the tools and explains their results.
  • Verifies its own answers. After a chat reply streams, a checker looks up every figure in the tool results. A second stage reviews the wording for unsupported causes, advice-like phrasing and data gaps. The verdict is shown in the activity timeline.
  • Stays compliant. It is simulation only. An Amazon Bedrock guardrail denies personalized advice and real trades, blocks identity and bank numbers, and filters prompt attacks.

How we built it

  • Frontend: Next.js dashboard with sign-in, portfolios stored in Aurora PostgreSQL, a streaming finance chat, and RiskRipple pages for alerts and manual investigations.
  • Backend: FastAPI, with prices from Yahoo Finance, news from StocksFeed, sanctions lists (OFAC and Global Affairs Canada), macro series (FRED), SEC filings, and Bank of Canada exchange rates.
  • AWS:
    • Amazon Bedrock (Converse and ConverseStream with tool use) for the chat and the alert recommendations.
    • Strands agents on Bedrock for the investigation.
    • A Bedrock Knowledge Base over cleaned filings, with a hybrid search that combines literal and semantic retrieval.
    • Bedrock Guardrails.
    • ECS, CodeBuild and ECR for deployment.
  • Design rule: code calculates, the model explains. Every number must be traceable.

Challenges we ran into

  • False alarms. Early matching flagged the "Silicon Valley" homonym and generic procedural phrases as companies. We separated direct mentions from supplier and material links, and we now require quantified exposure evidence before an alert is confirmed.
  • Speed. A full agent run took about 70 seconds. Scanning many documents across many portfolios that way was impractical, so the scan uses one grounded, non-agentic Bedrock call per relevant match, with a cache and background refresh.
  • Trusting the model's numbers. Language models can state a figure that no tool returned. That led us to build the two-stage verifier.
  • Model access. Bedrock refused the bare model ID. We had to use an inference-profile ID, and the personal AWS account could not invoke the agents, so live testing happened on the event account.
  • Time. The whole project, from the first commit to the submission, took about a day and a half.
  • Guardrail tuning. Short French questions such as "Dois-je vendre mes actions TD maintenant ?" are not always caught by the denied-topic detector, so we rely on the system prompt too.

Accomplishments that we're proud of

  • A working end-to-end loop: an event arrives, the portfolio is checked, the exposure is shown as a weight, and every claim links to evidence.
  • Answers that check themselves, with a verdict visible in the interface.
  • A multi-agent design where each agent has one clear role, as the organizers asked, instead of agents added for show.
  • Compliance built in from the start: simulation only, source and date on every figure, and a versioned guardrail stored in the repository.

What we learned

  • The number of agents matters less than the role of each one and the evidence it hands over.
  • Deterministic code for the math, with a model that only explains it, makes verification possible.
  • Public data has limits, so we document gaps instead of hiding them.
  • A guardrail needs real test questions. Setting every filter to the maximum would block legitimate persona analysis.

What's next for PolyFinances AlphaForge: RiskRipple

  • Test the guardrail and the agents against more real questions, in French and English.
  • Add more regulatory and sanctions sources, and more company links in the exposure graph.
  • Add ESG and other non-financial criteria, so Mateo's preferences shape the analysis.
  • Add a debate agent that challenges the conclusions of the other agents.
  • Move the checks into a regular test suite that runs on every deployment.

Built With

Share this project:

Updates

Submission history