ChargeGuard

The only subscription you'll never have to babysit.

Comment

Inspiration

We've all been there: you check your bank statement and notice a subscription charge that's suddenly $10 more than last month. No email, no warning just a silent price hike. You could fight it. You could dig up old invoices, find the terms of service, write to support, wait for a reply, negotiate a partial refund, decide whether to accept. But it's $10. So you shrug and move on.

Multiply that by every subscription, every household, every month. Companies count on friction winning. We wanted an agent that removes the friction one that fights these small battles automatically, and only wakes you up when there's a real decision to make.

What it does

ChargeGuard is an autonomous AI agent that monitors your recurring subscription charges and disputes anomalies on your behalf.

When an unexpected charge lands a price hike, a double charge, a bill after cancellation

ChargeGuard:

  1. Detects the anomaly by comparing against historical charges for that merchant
  2. Investigates by gathering evidence: past invoices, subscription terms, and searching your inbox for any price-change notice the merchant should have sent
  3. Files the dispute directly with the merchant's support channel, with the evidence attached
  4. Negotiates the counter-offer when the merchant replies
  5. Pauses and asks you only when there's an actual decision to make ("Accept partial refund or push for full refund?")
  6. Closes the case once you decide, and reports what was recovered

You go from spending 30 minutes on a $10 refund to spending 5 seconds tapping one button.

How we built it

Agent framework: AWS Strands Agents SDK (Python), using the Agents-as-Tools pattern. A DisputeOrchestrator coordinates four specialized sub-agents:

  • ChargeAnalysisAgent detects and classifies the anomaly
  • EvidenceAgent gathers supporting artifacts
  • DisputeAgent files and monitors the claim
  • NegotiationAgent evaluates counter-offers and hands the decision to the user

Model: Amazon Bedrock (Claude) Runtime: Amazon Bedrock AgentCore Runtime Storage: DynamoDB (cases, transactions, decisions) + S3 (invoices, emails, evidence) Events: Amazon EventBridge Backend: FastAPI on AWS Lambda + API Gateway Frontend: React + TypeScript + Tailwind, deployed on AWS Amplify Hosting Observability: CloudWatch + AgentCore Observability

For the demo, we built two mock services a Banking API and a Merchant Support API so the full flow runs end-to-end without depending on any real third-party integration.

Challenges we ran into

  • Designing the human-in-the-loop boundary was harder than expected: deciding exactly which choices the agent can make alone versus which it must escalate took several iterations before it felt right.
  • Getting the Agents-as-Tools pattern to produce consistent, structured outputs required careful prompt design and Pydantic schemas for each sub-agent's response.
  • Deploying a multi-agent Strands application on AgentCore Runtime was new territory we spent time understanding how to package the orchestrator and its dependencies.
  • Simulating a realistic merchant negotiation (with counter-offers and reasonable timing) without over-engineering the mock service.

Accomplishments that we're proud of

  • A fully autonomous end-to-end flow from anomaly detection through evidence gathering, dispute filing, and negotiation that only surfaces the user for one decision.
  • A thoughtful human-in-the-loop design: the agent acts alone when it should and stops when it shouldn't. We can point to the exact rules.
  • Real multi-agent orchestration, not a single monolithic prompt: four specialized agents with their own tools, coordinated by an orchestrator.
  • A live demo that anyone can walk through in under 3 minutes and immediately understand.

What we learned

  • Strands Agents' multi-agent patterns, especially Agents-as-Tools for building coordinated systems with clear responsibilities.
  • Bedrock AgentCore Runtime for hosting agents in a serverless, production-ready way.
  • Structured outputs and tool contracts matter more than clever prompting when you want reliable agent behavior.
  • The hardest part of an "autonomous" agent isn't making it act it's deciding when it shouldn't.

What's next for ChargeGuard

  • Real bank integration through Plaid or similar aggregators, replacing the mock Banking API.
  • Real merchant channels: email, contact forms, and eventually chat, so the agent can actually file disputes with real companies.
  • Expanded dispute types: undelivered purchases, duplicate charges across different cards, free-trial-to-paid conversions the user didn't consent to.
  • Learning from outcomes: the agent should learn which merchants respond to which arguments and adapt over time.
  • Mobile app with push notifications for the (rare) moments the agent needs a decision.
  • Multi-user, family plans: one household, one ChargeGuard, protecting everyone's subscriptions.

Built With

Share this project:

Updates

Submission history