Inspiration

Important decisions rarely fail because people had no information. They fail because one important assumption was wrong and nobody tested it before committing.

When facing a major decision, people usually ask AI:

“What should I do?”

We wanted to ask a different question:

“What could make this decision fail — and what should I test before I commit?”

That idea became REGRET ENGINE.

Whether the decision is accepting a job, pursuing a degree, investing money, launching a business, buying something expensive, hiring someone, or making a technology change, REGRET helps users uncover what their decision depends on, challenge their reasoning, identify the conditions that could make it fail, and find the most valuable uncertainty to test.

The goal isn't to make AI decide for people.

The goal is to help people make decisions they can defend — and decisions they are less likely to regret.

What it does

REGRET ENGINE performs the decision-validation work for the user — structuring the decision, interrogating assumptions, evaluating evidence, identifying failure conditions, determining what uncertainty matters most, designing a validation experiment, and updating the decision when new evidence arrives

A user starts with a decision in their own words. REGRET conducts an adaptive interview to understand the goal, constraints, beliefs, alternatives, evidence, and uncertainties.

It then uses nine specialized agents:

Decision Analyzer — builds a structured model of the decision.
Assumption Hunter — identifies what must be true for the decision to succeed.
Blindspot Hunter — finds missing questions, dependencies, and overlooked factors.
Evidence Agent — evaluates available evidence and identifies support, contradictions, and gaps.
Devil's Advocate — challenges the strongest reasoning behind the decision.
Regret Simulator — explores realistic ways the decision could fail.
Threshold Engine — identifies the conditions or thresholds that could break the decision.
Value-of-Information Agent — determines which uncertainty is most valuable to resolve first.
Experiment Planner — designs the smallest credible experiment to test that uncertainty.

The system then closes the loop:

Decision → Stress Test → Failure Condition → Threshold → Experiment → Result → Re-evaluation → Learning → Next Experiment

Instead of ending with an AI-generated recommendation, REGRET can learn from what actually happened.

Its Decision Memory preserves what the user believed, what was tested, what happened, and what was learned. Its adaptive loop can then use that information to determine what should be investigated next.

Most importantly, REGRET does not make the final decision for the user.

It helps answer:

“Here is what could make your decision fail. Here is what you should test before committing.”

Impact

REGRET ENGINE is designed for decisions where the cost of being confidently wrong is high: career moves, education choices, business investments, technology changes, hiring decisions, and other irreversible commitments.

The goal is not to replace human judgment. It is to reduce the chance that a person commits to a major decision based on an assumption that was never tested.

By turning uncertainty into measurable conditions and small validation experiments, REGRET can help users replace expensive guesses with evidence before making an irreversible commitment.

Over time, Decision Memory and Decision Evolution allow the system to learn from what actually happened rather than treating every decision as an isolated AI conversation.

How we built it

REGRET ENGINE is built as a multi-agent system using the Strands Agents SDK and Amazon Bedrock.

The architecture is:

React + TypeScript
        │
        ▼
     FastAPI
        │
        ▼
Strands Agent Orchestrator
        │
        ├── Decision Analyzer
        ├── Assumption Hunter
        ├── Blindspot Hunter
        ├── Evidence Agent
        ├── Devil's Advocate
        ├── Regret Simulator
        ├── Threshold Engine
        ├── Value-of-Information Agent
        └── Experiment Planner
        │
        ▼
   Experiment
        │
        ▼
     Result
        │
        ▼
 Re-evaluation Engine
        │
        ├── Decision Memory
        ├── Adaptive Experiment Loop
        └── Decision Evolution
        │
        ▼
Amazon DynamoDB + Amazon S3

Each agent has a focused responsibility and passes structured, validated outputs to the next stage rather than repeatedly analyzing the original prompt independently.

We use Amazon DynamoDB for decision state, analysis results, thresholds, experiments, memory, and evolution data, while Amazon S3 stores uploaded evidence files.

The frontend is built with React, TypeScript, Vite, and Tailwind CSS, while the backend uses FastAPI and Python.

We also deliberately use deterministic logic where appropriate. Numerical comparisons, threshold evaluation, state transitions, and experiment-result comparisons are not delegated blindly to an LLM.

This gives REGRET a hybrid architecture:

LLM reasoning for interpretation + deterministic services for decisions that require consistency.

Challenges we ran into

1. Avoiding “another AI recommendation tool”

Our first challenge was conceptual.

It is easy to build an AI that says:

“I recommend option A.”

It is much harder to build a system that identifies what evidence would change that conclusion.

We therefore redesigned REGRET around uncertainty, thresholds, and experiments rather than recommendations.

2. Preventing confident hallucinations

Decision systems can be dangerous when an AI invents statistics, probabilities, sources, or thresholds.

We introduced structured outputs, evidence provenance, confidence levels, explicit unknown states, and deterministic calculations to keep unsupported claims from becoming artificial facts.

3. Making nine agents work as one system

The agents needed clear responsibilities and contracts.

For example, the Assumption Hunter identifies assumptions, while the Threshold Engine determines whether those assumptions can be translated into measurable decision conditions. The Experiment Planner then uses those conditions to design a test.

This separation made the system more controllable and explainable.

4. Making the product universal

A career decision and a database migration should not receive the same questions.

We built an adaptive interview that changes its questions based on the decision type, decision content, previous answers, and remaining uncertainties.

5. Making decisions learn from reality

A decision shouldn't remain frozen after an experiment.

We built re-evaluation, Decision Memory, Value of Information, adaptive experiment selection, and Decision Evolution so the system can move from:

What we believed → What we tested → What happened → What we learned → What we should test next.

Accomplishments that we're proud of

🧠 A real multi-agent decision pipeline

REGRET isn't a single prompt wrapped in a dashboard.

Nine specialized agents perform distinct stages of decision analysis and pass structured outputs through the pipeline.

🎯 We turned uncertainty into experiments

Instead of simply identifying:

“Customer demand is risky.”

REGRET tries to determine:

“What level of customer behavior would make this decision viable, and what is the cheapest way to test it?”

🔬 Value of Information

REGRET doesn't simply choose the largest risk.

It asks:

“Which uncertainty is worth resolving first?”

This helps prioritize experiments based on their potential impact, evidence strength, feasibility, reversibility, and information value.

🔄 Closed-loop re-evaluation

After an experiment, the system doesn't simply append the result to a report.

It compares the observed result against the relevant threshold and updates the decision assessment.

🧠 Decision Memory

REGRET remembers what happened to previous decisions so users can build a personal history of validated and failed assumptions.

🧭 Decision Evolution

Users can see the journey of a decision:

Original belief → Critical uncertainty → Threshold → Experiment → Result → Learning → New assessment

🌍 Domain independence

The same engine can analyze decisions across:

Career • Education • Financial • Personal • Business • Technology • Product • Hiring • Strategy

The domain changes, but the underlying decision-validation mechanism remains the same.

What we learned

We learned that building a useful AI agent is not primarily about generating more intelligent text.

It is about giving the AI the right job to do.

We found that asking:

“What should I do?”

often encourages AI to produce a confident answer.

Asking:

“What would make this decision fail?”

creates a much more useful process.

We also learned that uncertainty doesn't always need another prediction.

Sometimes the best AI output is:

“Don't commit yet. Run this small experiment first.”

Finally, we learned that agentic systems become significantly more reliable when responsibilities are separated, outputs are structured, evidence is traceable, and deterministic logic is used wherever precision matters.

What's next for REGRET ENGINE

Our next goal is to make REGRET useful throughout the lifetime of a user's decisions, rather than only at the moment a decision is created.

🔄 More adaptive conversations

Make the interview increasingly natural and efficient, asking only the questions necessary to resolve the most important uncertainties.

🧠 Cross-decision learning

Identify recurring patterns across a user's own decisions — such as assumptions that repeatedly fail or uncertainties that repeatedly remain unresolved.

🎯 Smarter experiment selection

Improve the system's ability to find the cheapest, fastest, and most informative experiment before an irreversible commitment.

📚 Richer evidence

Expand source-grounded research while maintaining a clear distinction between verified evidence, user-provided information, historical learning, and AI inference.

📈 Long-term decision intelligence

Ultimately, we want REGRET to become a personal decision memory layer:

It remembers what you believed, challenges what you assumed, learns from what actually happened, and helps you approach your next important decision with better evidence.