Ripple

Inspiration

Major life changes rarely affect just one thing.

A move, job change, marriage, new child, or other major event can create consequences across government requirements, insurance, taxes, finances, healthcare, and everyday life. The problem is that people often don't know all the questions they should be asking.

Most assistants are good at helping users complete a known task. Ripple started with a different question:

Something changed. What else does that change?

The goal became an agent that doesn't simply work through a predetermined checklist. It investigates an event, discovers its consequences, determines which ones actually apply, and follows those consequences to discover additional downstream effects.

Other agents help complete your to-do list. Ripple discovers the to-do list you didn't know existed.

What it does

Ripple is a consequence-discovery agent built with the Strands Agents SDK.

A user provides a major life event and relevant context. Ripple investigates that event using bounded tools and evidence, discovers potential consequences, evaluates whether each consequence applies, and builds a recursive graph showing how one change can lead to another.

For the hackathon demonstration, Ripple uses a completely synthetic scenario: Alex Morgan moves from Indianapolis, Indiana to Columbus, Ohio.

Rather than beginning with a hard-coded moving checklist, Ripple investigates the event and builds the consequence graph at runtime.

Consequences can end as ACTION_PREPARED, DOES_NOT_APPLY, HUMAN_DECISION, UNKNOWN, or RESOLVED.

This allows Ripple not only to identify actions, but also to preserve uncertainty and reject consequences that don't actually apply.

How we built it

Ripple combines the Strands Agents SDK with a deterministic trust and validation layer.

Strands handles the investigation and reasoning process: discovering consequence candidates, selecting investigation tools, evaluating evidence, determining applicability, and identifying downstream consequences that deserve further investigation.

The surrounding deterministic layer validates graph mutations and provides safeguards against weak evidence, unsupported deadlines, duplicate consequences, evidence misuse, and unsupported child relationships.

Ripple uses tools for person-context retrieval, domain investigation, duplicate detection, consequence recording, and recursive investigation spawning. Evidence-backed conclusions use verified public sources, including official government resources.

The result is a recursive consequence graph rather than a flat checklist.

Challenges we ran into

The hardest challenge was balancing autonomous discovery with trust.

Allowing an agent to discover consequences creates the risk of unsupported conclusions. We separated agent reasoning from deterministic safeguards and required evidence for important graph mutations and claims.

Recursive discovery also meant preventing duplicate nodes, cycles, irrelevant branches, and uncontrolled expansion without turning Ripple into a predetermined decision tree.

Near submission, we encountered an infrastructure limitation when the managed model gateway exhausted its available usage capacity. Rather than add a mock fallback or present a replay as a fresh execution, we published an earlier genuine live Strands execution and its validation artifacts. The repository documents this limitation transparently.

Accomplishments that we're proud of

Ripple demonstrated that an agent can go beyond completing a predefined workflow and instead discover the workflow itself.

Our preserved genuine live Strands execution produced a 13-node consequence graph with 12 parent-child relationships, 32 evidence records, and 65 tool/activity events.

Most importantly, Ripple discovered three depth-two consequences: consequences that emerged because another discovered consequence created a new investigation.

That run passed 14/14 runtime validators covering evidence, reasoning, recursion, graph behavior, and safeguards.

We're also proud that Ripple treats UNKNOWN and DOES_NOT_APPLY as legitimate outcomes rather than forcing every investigation into an action.

What we learned

The biggest lesson was that useful agentic AI isn't only about automating actions.

There is another valuable role for agents: discovering what deserves attention in the first place.

We also learned that agent autonomy and deterministic software controls can complement each other. Strands can perform open-ended investigation and reasoning while conventional code enforces evidence, provenance, graph integrity, and safety constraints.

Finally, uncertainty is a legitimate result. A trustworthy agent should be able to say that something is unknown, requires a human decision, or does not apply.

What's next for Ripple

The current prototype demonstrates consequence discovery through a synthetic interstate-move scenario, but Ripple's underlying architecture is event-driven rather than move-specific.

Next, we would expand the evidence layer and domain coverage so Ripple can investigate additional major life events while preserving the same evidence, applicability, recursion, and trust requirements.

Over time, Ripple could become a general-purpose consequence-discovery layer that helps people understand the second- and third-order effects of important changes before something gets missed.

Tell Ripple what changed. Let Ripple discover what else that changes.

Built With

• agentic
• agents
• ai
• calling
• evidence-based
• generative
• node.js
• openai
• python
• react
• reasoning
• recursive
• sdk
• strands
• tool
• typescript
• vite