ClaimInvestigator: AI Transaction Dispute Investigator

A Strands AI agent on Amazon Bedrock AgentCore that investigates transaction disputes end to end, gathers evidence, validates completeness, and keeps financial decisions under deterministic control.

Comment

Inspiration

Transaction-dispute investigation is a workflow where much of the effort happens before a decision can even be made.

For an ACH or ATM dispute, an investigator may need to retrieve the claim, identify the correct procedure, review transaction activity, verify customer authorization, gather evidence, and confirm that every required check has been completed.

I wanted to explore whether an AI agent could perform that investigation end to end rather than simply assist through chat.

That led to ClaimInvestigator.

Let the AI investigate. Keep the financial decision deterministic and auditable.

What it does

An analyst enters a Claim ID.

ClaimInvestigator then:

  • retrieves the claim and identifies the dispute type,
  • loads the applicable investigation procedure from Amazon S3,
  • uses Strands tools to gather transaction and authorization evidence,
  • verifies that all required investigation checks were completed,
  • produces an investigation summary,
  • passes validated findings to deterministic business rules,
  • returns the recommendation together with an auditable tool-call history.

The analyst does not need to manually prompt the agent through each step.

In the main demo, ClaimInvestigator investigates a $75,000 ACH dispute. It identifies two $75,000 ACH transactions from the same originator, reviews $150,000 of related transaction activity, establishes that the customer reported the transaction as unauthorized, and confirms that all required ACH checks were completed.

Enter Claim ID → Investigate → Review findings and recommendation

How I built it

I built ClaimInvestigator using Strands Agents and Python, with the agent deployed on Amazon Bedrock AgentCore Runtime.

The full execution path is:

Web UI → FastAPI → AgentCore Runtime → Strands Agent → Tools / S3 Procedures / Evidence → Completeness Validation → Deterministic Recommendation

The Strands agent uses purpose-built tools for claim retrieval, procedure loading, transaction history, customer authorization, and completeness validation.

ACH and ATM procedures are stored as JSON in Amazon S3, keeping business procedures outside the model prompt and making them easier to update and govern.

The application uses:

  • Strands Agents for orchestration and tool execution
  • Amazon Bedrock AgentCore Runtime for deployed agent execution
  • AgentCore Identity for secure outbound authentication
  • Anthropic Claude for reasoning and evidence synthesis
  • Amazon S3 for investigation procedures
  • Python for validation and deterministic business rules
  • FastAPI for the application API
  • HTML, CSS, and JavaScript for the analyst-facing UI

The key architectural decision was separating investigation from financial decisioning.

The agent can reason, select tools, gather evidence, and summarize findings. The final recommendation and refund amount are produced by explicit Python business rules.

Challenges I ran into

The first challenge was making the system behave like an agent rather than a chatbot.

A model can generate a convincing investigation summary without actually performing an investigation. I addressed this by exposing the investigation capabilities as tools and requiring the agent to retrieve evidence during execution.

The second challenge was completeness. Calling several tools does not prove that every required procedural check was completed, so I added a separate validation layer that compares completed checks with the applicable procedure.

This also exposed an important failure mode: if the procedure could not be loaded, the validator could incorrectly see zero required checks. I changed it to fail closed so a missing or invalid procedure makes the investigation incomplete.

Deploying to AgentCore introduced another set of challenges: Linux ARM64 packaging, native dependencies, IAM permissions, AgentCore Identity, Secrets Manager access, and caller permissions for InvokeAgentRuntime.

Working through those issues was a major part of moving the project from a local prototype to a deployed workflow.

Accomplishments that I am proud of

The part I am most proud of is that ClaimInvestigator performs real work end to end.

The user provides a Claim ID, and the agent determines the claim context, retrieves the correct procedure, gathers evidence, validates the investigation, and produces a structured result without requiring step-by-step prompting.

I am also proud of the separation between agent reasoning and deterministic decisioning. It demonstrates how agentic AI can be useful in financial workflows without giving an LLM unrestricted authority over consequential decisions.

The agent is deployed on Amazon Bedrock AgentCore Runtime, uses AgentCore Identity for secure outbound authentication, and is invoked directly from the analyst-facing web application.

What I learned

The biggest lesson was that the prompt was the easy part.

The harder questions were architectural:

  • What tools should the agent have?
  • What information should remain outside the model?
  • How do I know the investigation is complete?
  • What should happen when a dependency fails?
  • Where should the agent's authority stop?
  • How should identity, secrets, IAM, and runtime deployment be handled?

For this kind of enterprise workflow, the architecture I find most compelling is:

Agent reasoning + external procedures + deterministic controls + human oversight

rather than making every part of the process agentic.

What's next for ClaimInvestigator

The current version demonstrates the architecture for ACH and ATM disputes using simulated claim and transaction data.

The next step is to connect the same architecture to real transaction, fraud, authorization, and case-management systems.

I would also add:

  • more dispute types,
  • persisted evidence and investigation history,
  • procedure versioning and governance,
  • human review and approval,
  • authentication and role-based access control,
  • richer anomaly detection,
  • production observability.

The longer-term vision is an agentic investigation layer for financial operations where AI agents perform repetitive investigative work, external procedures define what must be checked, and deterministic controls and people retain authority over consequential decisions.

Built With

Share this project:

Updates

Submission history