AIdeas: CareLens AI — Transparent Care Guidance When It Matters Most.
CareLens is a privacy-first AI platform that helps people understand healthcare costs before seeking treatment. By analyzing de-identified symptoms, location, and optional insurance details, it compares care options like ER, urgent care, or specialists and surfaces real-world price ranges using hospital transparency and CMS data. It doesn’t diagnose—it delivers clear, grounded cost and care guidance so users can make confident decisions without surprise bills.
AIdeas: CareLens
App Category
Social Impact
#aideas-2025 #social-impact #NAMER #healthcare-transparency #financial-literacy #hipaa-aware-design #agentic-ai #serverless-architecture #aws-bedrock #preventive-care #AI #AIinHealthcare
My Vision
Healthcare doesn’t fail because medicine is weak. It fails because navigation is unclear. When something feels wrong, most people don’t need a diagnosis first—they need direction.
Where should I go? What will it cost?
I built CareLens to answer those questions before uncertainty turns into delay. CareLens is a privacy-first healthcare wayfinding platform that delivers cost clarity and structured guidance at the moment someone is deciding what to do next. It does not diagnose or replace clinicians; it functions as a decision-navigation layer that translates symptoms and context into clear care options and transparent cost expectations.
At its core is the CareLens Wayfinding Engine, a structured reasoning system that evaluates de-identified symptom descriptions, location, and optional insurance context to generate grounded care pathways.
CareLens provides:
- The most appropriate care setting (ER, Urgent Care, or Specialist).
- Nearby provider options from public directories.
- Real-world cost ranges for visits and common tests.
- Insurance-aware out-of-pocket or self-pay estimates.
- Clear explanations for every recommendation.
All outputs are grounded in authoritative public datasets, including hospital price-transparency files and government fee schedules. The system renders structured results focused strictly on logistics and financial clarity. By accepting only de-identified inputs and enforcing strict output constraints, CareLens is designed with a HIPAA-conscious architecture (de-identified inputs, no PHI storage) — not a covered entity, but built to the same standard of restraint.
Why this matters
Mark Cuban captured the core problem: when it comes to healthcare, people don’t know what anything will cost. When the price is unknown, the human brain often defaults to avoiding the risk. It turns “I should get this checked” into “let me wait a little longer.”
While price-transparency rules exist, the data is often buried in massive, inconsistent files that are technically available but practically unusable for everyday people. The result is a global crisis of deferred care. In North Alabama, where I built this, over a third of adults delayed care due to cost — a pattern repeated across the US, Canada, and Australia:
- USA: 36% of adults skipped or postponed care last year due to cost.
- Canada: 1 in 4 people avoid oral health professionals because of price.
- Australia: Nearly 10% of people delay seeing a GP due to financial concerns.
- Tools like Turquoise Health surface raw pricing files — CareLens goes further by translating that data into a decision, not just a number.
To see if these numbers matched reality, I stepped away from the code and conducted a series of user interviews. I spoke with family members, reached out to hospital administrators, and sat down with everyday people who had recently navigated the system. The feedback was hauntingly consistent. One person told me they felt "financially blindfolded" the moment they stepped into a clinic. A hospital contact admitted that while the data is "public," it wasn't designed for humans to actually read. I’ve seen this up close in my own family, too. My aunt once chose to endure worsening symptoms rather than walk into a hospital without knowing the potential bill. By the time she finally sought help, a manageable issue had become serious.
CareLens exists for that exact moment. It turns "hidden-in-plain-sight" pricing into plain-language options so people can act earlier without gambling their financial future. That’s why this is Social Impact: when clarity becomes usable, people don’t freeze—they move.
How CareLens Works — and Why It’s Different
Using CareLens is simple. You describe your situation in plain language, add your location, and optionally upload insurance details. The system may ask a few clarifying questions to reduce ambiguity. Then, its AI engine evaluates the appropriate setting and checks real pricing data.
Example Scenario:
User Input: “I’ve had a fever of 102°F for two days with body aches and chills.”
CareLens Response:* Recommended Setting: Urgent Care* Estimated Cost: $95–$250 (Insured) | $150–$350 (Self-pay)* Why: Symptoms suggest a non-emergency infection that can be evaluated outside the ER, reducing unnecessary costs.* What to Bring: Insurance card and a list of current medications.
CareLens does not diagnose or prescribe. It provides the logistical and financial guidance that traditional symptom checkers and hospital websites lack.
How I built this
Technical Approach & Architecture
I built CareLens as a privacy-first, serverless wayfinding system. A key design influence came from agentic health-assistant research (g-AMIE style), which shows that users trust systems more when the AI asks clarifying questions and explains its reasoning rather than jumping to conclusions.
Architecture End-to-End
CareLens is designed as a deterministic orchestration layer centered around a constrained LLM, rather than a traditional chatbot. The system decouples reasoning, grounding, and delivery, ensuring that while AI assists in structuring context, all safety and cost logic remains verifiable and reproducible. This separation reflects architectural patterns validated in a March 2026 npj Digital Medicine scoping review, which found that systems combining goal-directed reasoning with structured data grounding significantly outperform single-model approaches in safety and auditability.
Interface Layer
The person using CareLens is usually anxious. They've typed something like "fever for two days" and they need to feel like the system is listening, not processing. The frontend reflects this: a conversational intake on the left lets the user speak naturally, while a guidance panel on the right updates continuously as context is added. Each piece of new information — insurance type, location, symptom duration — visibly narrows the cost range and sharpens the recommendation. Users don't just get an answer; they watch uncertainty shrink in real time, which builds trust before the output even arrives.
Reasoning Layer (Amazon Bedrock)
The reasoning layer uses Claude 3 Haiku via Amazon Bedrock, but the model is restricted to producing strictly validated JSON schemas rather than free-form text. This structured contract ensures the model only outputs logistical signals—care setting, urgency band, clarification questions, and next-step guidance. Deterministic guardrails then arbitrate the final decision so the system never produces diagnosis or treatment instructions.
Grounding Layer (DynamoDB Pricing Index)
CareLens maintains a normalized pricing index derived from hospital price-transparency machine-readable files, CMS physician fee schedules, and facility metadata. These heterogeneous datasets are aggregated and transformed into a low-latency lookup layer that maps real-world facilities and payer contexts to regional cost bands.The pricing and wayfinding tools are exposed through an MCP server interface, enforcing explicit tool boundaries that prevent the reasoning layer from accessing any data outside its defined scope — a structural privacy guarantee rather than a mere policy based one.
Security & Edge Layer (API Gateway)
Amazon API Gateway serves as the system boundary, enforcing schema validation, rate limiting, and authentication. Inputs are de-identified immediately at ingestion, and observability logs are stripped of identifiers to ensure operational visibility without storing sensitive data.
Development Loop (Amazon Kiro)
During development, Amazon Kiro was used for deep debugging and tightening the feedback loop between LLM outputs and the structured pricing layer. This was critical for aligning model outputs with deterministic safety constraints.
In January 2026, AWS published an open-source HealthLake MCP server, describing MCP as a framework that "streamlines healthcare data operations by providing natural language interfaces to FHIR resources." By utilizing Kiro as the MCP client, the debugging loop was an MCP-native workflow: each agent's tool boundaries were explicit and auditable rather than hidden within implicit prompt logic.
Execution Flow
Ingestion
User input is received through the frontend and routed to a Lambda orchestrator that immediately strips identifiers and converts the request into a structured context object.
Reasoning
The context object is passed to Claude 3 Haiku via Amazon Bedrock with a constrained system prompt that restricts output to a validated JSON schema. The model determines whether the current context is sufficient to produce a recommendation — if not, it emits a structured clarification request rather than guessing. Once context is complete, it outputs a recommendation schema containing care setting, urgency band, and next-step signals only. The model has no access to pricing data and cannot produce cost figures — that separation is enforced by the schema contract, not prompt instructions.
Grounding
The recommendation schema triggers a deterministic lookup against the DynamoDB pricing index — a normalized dataset derived from CMS physician fee schedules and hospital price-transparency machine-readable files. No pricing figure is model-generated; every cost range is retrieved from a verifiable source record. If the lookup returns insufficient data for a given region or payer context, the system surfaces a bounded range with an explicit confidence indicator rather than fabricating precision it doesn't have.
Delivery
The frontend renders the synthesized guidance in the dual-track interface: recommended care setting, expected cost band, and logistical next steps—while maintaining strict separation between logistical navigation and clinical decision-making.
DEMO
Click above to watch the CareLens Wayfinding Demo.
🚀 Try the Live App: www.carelens.app
What I Learned
Building CareLens fundamentally shifted how I view AI.
At the start, I was focused on the "puzzle" of the infrastructure—the satisfying click of wiring together AWS Lambda, API Gateway, and DynamoDB. But as I got deeper, I realized the real challenge wasn't the compute; it was the weight of the responsibility. Healthcare isn't a space where "mostly right" is good enough. I learned that designing for sensitive contexts requires more restraint than creativity. The most vital decisions weren't about model speed, but about the invisible safety net: the guardrails, the refusal logic, and the obsession with ensuring we never crossed the line into medical advice.
I also had a major "aha!" moment regarding grounding. We’ve all seen models give confident, polished answers that are factually hollow. I learned that in healthcare, confidence without a data trail is a liability. By moving cost reasoning into structured data pipelines—grounded in real CMS fee schedules and hospital transparency files—the system stopped "guessing" and started "calculating."
A turning point in this journey was working within the Kiro development environment. It’s one thing to have a vision for a multi-agent system; it’s another to actually debug the handoffs between a Logistics Agent, a Cost Agent, and a Guardrail Agent. I used Kiro to iterate on these reasoning loops, and it taught me that multi-agent consensus isn't just a buzzword—it’s how you build an auditable system that doesn't "break" under the complexity of a user’s real-life stress.
The biggest takeaway? Responsible AI isn’t a coat of paint you apply to a finished product. It is the architecture.
Mistakes I Made (and What They Taught Me)
- Over-trusting model outputs Early versions sometimes produced confident but illogical recommendations—answers that sounded convincing but lacked factual grounding. I corrected this by moving cost reasoning out of the model and into structured pipelines backed by CMS fee schedules and hospital transparency datasets. The model now interprets real data rather than inventing estimates.
- Underestimating mobile browser behavior
Mobile Safari revealed issues that never appeared on desktop. Authentication tokens behaved differently across browser storage layers, causing login failures and session persistence problems on iPhone and iPad. Fixing this required implementing a Safari-safe authentication flow and improving token handling and retry logic. - CORS and API Gateway configuration pitfalls
Several API endpoints initially failed on mobile because preflight (OPTIONS) responses were missing in API Gateway. Desktop browsers masked the problem through caching, but mobile devices exposed it immediately. Properly configuring CORS responses and redeploying the gateway resolved the issue. - Infrastructure configuration drift
During deployment with AWS SAM, small environment mismatches created production issues—such as incorrect environment variables, leftover localhost references, and misconfigured API base URLs. This led me to add stricter build validation and infrastructure verification scripts. - Multi-agent orchestration complexity
Coordinating multiple reasoning agents introduced edge cases where outputs from the Logistics Agent and Cost Agent could conflict. Adding clearer orchestration rules, consensus checks, and a guardrail validation layer ensured outputs were consistent before reaching users.
These mistakes reinforced an important principle: AI systems rarely fail because of a single model—they fail at the seams between infrastructure, data, and reasoning layers. Strengthening those seams became the real work of building CareLens.
What's next for CareLens
CareLens is still early, and the next phase focuses on five key expansions.
Expanded data coverage. The current pricing index will grow to include additional regional hospital transparency files, with dedicated coverage for dental and mental health services — two of the most cost-opaque areas in American healthcare and two of the most commonly deferred.
Specialist routing and booking. CareLens will move beyond ER and Urgent Care to guide users toward OB-GYN, dermatology, and psychiatry booking pathways — translating the same wayfinding logic into specialties where cost uncertainty causes the longest delays.
The CareLens Pass. Every completed wayfinding session will generate a structured care artifact — saved to Apple Wallet or Google Wallet, with a scannable QR code shareable with a caregiver. It functions as a visit brief before you go, an emergency-readable beacon during transit, and a lightweight cost-comparison record after. One object, three states, no additional setup required.
Sustainable operations. CareLens will explore employer health benefit partnerships where organizations — not individual users — cover access costs, in exchange for aggregate, fully anonymized insights that help reduce unnecessary ER utilization across their teams. No individual data is monetized. Revenue exists to keep the platform running and the pricing data current, not to extract value from people who are already navigating a hard situation.
Continuous evaluation. A SHARP-style loop — Safety, Helpfulness, Accuracy, Relevance, Personalization — will validate outputs against real-world pricing variability, closing the gap between what CareLens estimates and what users actually pay.
The vision remains consistent: Turn healthcare cost opacity into actionable clarity—before care decisions are made.
If you believe healthcare transparency can change lives, please leave a Like below!
Please check it out here : (https://www.carelens.app/
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article