CareCircle: AI-Powered Multi-Agent Family Care System

🚀 Built during AI Agents Week-long Hack with Kiro

• Primary: https://main.d2as4i5wk0qiht.amplifyapp.com
• Secondary mirror: https://main.d2etapuevo33k.amplifyapp.com
• Demo credentials: demo / Demo1234

Existing eldercare apps are passive data logs. CareCircle is an active AI partner.

We built a multi-agent autonomous care system using AWS Kiro and Amazon Bedrock that doesn't just track data—it acts.

• Detects early cognitive decline by analyzing semantic patterns across weeks of conversations (currently showing 62% risk for our demo patient)
• Autonomously triages emergencies like the fall detected at 6:24 PM, instantly assessing severity and alerting caregivers only when necessary
• Intelligently assigns tasks to the right family member based on proximity, language, and availability
• Prevents caregiver burnout through AI-powered load balancing across the care network

Built with Kiro for rapid serverless development. Runs on AWS Free Tier for pennies. Scales to millions of families.

This is production-ready infrastructure for the 53 million family caregivers in America.

Core Project Docs:

• 🧭 Architecture + flows in this README.md
• ⚙️ Deployment context in amplify.yml, deploy.sh, and infrastructure code
• 📘 Deployed app user guide in docs/DEPLOYED_APP_NAVIGATION_FUNCTIONAL_GUIDE.md
• 🖼️ Guide screenshots in docs/screenshots/

Kiro Artifacts:

• 🧠 KIRO_DEVELOPMENT_CASE_STUDY.md
• 📐 .kiro/specs/care-operations-console/ (requirements, design, tasks)

CareCircle is an autonomous AI care team that helps distributed families collaboratively care for their elderly loved ones. Unlike passive monitoring apps, CareCircle uses AWS AI services to actively detect, triage, and coordinate care—acting as an intelligent partner that handles the complexity so families can focus on what matters: love and connection.

• Frontend: AWS Amplify Hosting, Amazon Cognito
• Voice/Video: Amazon Chime SDK, Amazon Connect (optional)
• AI Services:
  • Amazon Transcribe (speech-to-text)
  • Amazon Comprehend (sentiment & NLP)
  • Amazon Translate (multilingual support)
  • Amazon Bedrock (LLM reasoning)
• Backend: AWS Lambda, Amazon API Gateway, Amazon EventBridge
• Data: Amazon DynamoDB
• Notifications: Amazon SNS, Amazon SES
• Voice Interface: Amazon Lex, Amazon Polly (optional)
• Monitoring: Amazon CloudWatch

flowchart LR
    Family[Family Caregiver / Elder]

    subgraph Frontend["Frontend Layer"]
        Amplify[React App on Amplify]
        Cognito[Cognito Authentication]
    end

    subgraph Backend["Serverless Backend"]
        APIGW[API Gateway]
        Lambda[Lambda Handlers]
        Events[EventBridge]
    end

    subgraph AI["AI + Language Services"]
        Transcribe[Amazon Transcribe]
        Comprehend[Amazon Comprehend]
        Bedrock[Amazon Bedrock]
        Translate[Amazon Translate]
    end

    subgraph Data["State + Notifications"]
        Dynamo[DynamoDB]
        Notify[SNS / SES]
    end

    Family --> Amplify
    Amplify --> Cognito
    Amplify --> APIGW
    APIGW --> Lambda
    Lambda --> Transcribe
    Lambda --> Comprehend
    Lambda --> Bedrock
    Lambda --> Translate
    Lambda <--> Dynamo
    Lambda --> Events
    Events --> Lambda
    Lambda --> Notify
    Notify --> Family

flowchart TB
    subgraph AppShell["Application Shell"]
        App[App Router]
        Nav[Standardized Navigation]
        Header[Top Header]
        Theme[Theme + i18n]
    end

    subgraph Pages["Core Pages"]
        Dashboard[Dashboard]
        Today[Today Queue]
        Timeline[Timeline]
        Alerts[Alerts]
        Tasks[Care Actions]
        Reports[Reports]
        Analytics[Analytics]
        FamilyPage[Family Management]
        Meds[Medications]
        Emergency[Emergency Hub]
    end

    subgraph Components["Shared Components"]
        AlertBanner[Alert Banner]
        TaskCard[Task Card]
        ActionWorkflow[Take Action Workflow]
        Explainability[Explainability Drawer]
    end

    subgraph Services["Service Layer"]
        Api[API Client]
        Queue[Care Queue Engine]
        Assign[Assignment Engine]
        TimelineSvc[Timeline Manager]
        Risk[Risk Card Engine]
    end

    App --> Nav
    App --> Header
    App --> Theme
    App --> Pages
    Dashboard --> AlertBanner
    Dashboard --> TaskCard
    Alerts --> Explainability
    Today --> ActionWorkflow
    Pages --> Api
    Pages --> Queue
    Pages --> Assign
    Pages --> TimelineSvc
    Pages --> Risk

flowchart TB
    Client[Frontend / API Client] --> Gateway[API Gateway]
    Gateway --> ApiHandlers[api-handlers]
    Gateway --> Calls[call-handlers]
    Gateway --> MedsHandlers[medications-handler]
    Gateway --> Wellness[wellness-handler]
    Gateway --> Health[health-handler]

    Calls --> TranscribeFn[transcribe-handler]
    TranscribeFn --> Analyze[ai-analysis]
    Analyze --> AssignFn[task-assignment]
    AssignFn --> NotifyFn[notification-handler]

    ApiHandlers <--> DB[(DynamoDB)]
    Calls <--> DB
    MedsHandlers <--> DB
    Wellness <--> DB
    AssignFn <--> DB
    NotifyFn --> Channel[SNS / SES]
    AssignFn --> Bus[EventBridge]
    Bus --> NotifyFn

CareCircle isn't just a dashboard—it's an autonomous care team powered by multi-agent AI:

• Analyzes voice transcripts in real-time
• Detects falls, confusion, distress automatically
• Evaluates severity without human delay
• Dispatches appropriate protocols instantly
• Example: "Fall detected at 6:24 PM → Urgent Triage Protocol auto-dispatched in 2.3 seconds"

• Calculates optimal family member for each task
• Considers: proximity (ZIP), language, skills, availability
• Routes tasks intelligently across the care network
• Prevents caregiver burnout through load balancing
• Example: "Medication review assigned to Maria (Spanish speaker, 5 miles away, available today)"

• Analyzes weeks of conversation transcripts
• Detects semantic drift patterns (memory lapses, confusion)
• Generates risk scores (e.g., 62% cognitive risk)
• Alerts family before crisis occurs
• Example: "62% cognitive risk detected from 14 conversations over 3 weeks"

• Filters alerts by urgency
• Sends only actionable notifications
• Prevents alert fatigue
• Coordinates multi-channel delivery
• Example: "Urgent fall alert → SMS to 3 nearby family members in 5 seconds"

This project was developed using AWS Kiro, the AI-powered IDE, to rapidly prototype and deploy production-ready serverless architecture:

1. Multi-Agent Lambda Functions

   • Kiro generated the ai-analysis Lambda that orchestrates Transcribe → Comprehend → Bedrock
   • Created the task-assignment agent with intelligent family member matching logic
   • Built the escalation-handler for emergency triage protocols

2. Infrastructure as Code

   • Kiro wrote our AWS SAM template (template.yaml) with proper IAM roles
   • Generated DynamoDB single-table design with GSI indexes
   • Created EventBridge rules for event-driven architecture

3. Free Tier Optimization

   • Kiro optimized Lambda memory/timeout for cost efficiency
   • Implemented DynamoDB on-demand pricing strategy
   • Designed Transcribe streaming to minimize billable seconds

# Example: Building the Cognitive Monitoring Agent with Kiro
# Prompt: "Create a Lambda function that analyzes conversation transcripts 
#          using Bedrock Claude 3 Haiku to detect cognitive decline patterns"

# Kiro generated:
# - Lambda handler with Bedrock integration
# - Prompt engineering for cognitive assessment
# - Error handling and retry logic
# - CloudWatch logging for debugging

Time Saved: What would take 2-3 days of manual coding, Kiro delivered in hours.

CareCircle is designed to operate entirely within AWS Free Tier limits for the first year:

1. Lambda: 512MB memory, 30s timeout (minimal compute)
2. DynamoDB: On-demand pricing (pay only for actual reads/writes)
3. Transcribe: Streaming API (billed per second, not per minute)
4. Bedrock: Claude 3 Haiku (cheapest model, still highly capable)
5. S3: Not used (store transcripts in DynamoDB to avoid storage costs)

Estimated Monthly Cost: $0-5 per family (mostly Bedrock tokens)

1. 🚨 Real-Time Autonomous Triage

   • Agent: Triage Agent (Bedrock + Comprehend)
   • Action: Detects falls, confusion, distress in voice calls
   • Autonomy: Evaluates severity and dispatches protocols without human delay
   • Example: "Fall detected at 6:24 PM → Urgent Triage Protocol auto-dispatched in 2.3 seconds"

2. 🎯 Intelligent Task Assignment

   • Agent: Assignment Agent (Custom algorithm + Bedrock)
   • Action: Routes tasks to optimal family member
   • Autonomy: Considers ZIP code, language, skills, availability automatically
   • Example: "Medication review assigned to Maria (Spanish speaker, 5 miles away, available today)"

3. 🧠 Predictive Cognitive Monitoring

   • Agent: Cognitive Monitoring Agent (Bedrock 200K context)
   • Action: Analyzes weeks of transcripts for semantic drift
   • Autonomy: Generates risk scores and alerts before crisis
   • Example: "62% cognitive risk detected from 14 conversations over 3 weeks"

4. 🌍 Multilingual Care Coordination

   • Agent: Translation Agent (Amazon Translate)
   • Action: Real-time translation across 6 languages
   • Autonomy: Automatically matches caregiver language to elder preference
   • Languages: English, Spanish, Hindi, Arabic, Mandarin, Portuguese

5. ⚡ Event-Driven Architecture

   • Agent: Notification Agent (EventBridge orchestration)
   • Action: Filters and routes alerts by urgency
   • Autonomy: Prevents alert fatigue through intelligent filtering
   • Result: Family receives only actionable notifications

CareCircle/
├── frontend/                 # React + Amplify web application
│   ├── src/
│   │   ├── components/      # UI components
│   │   ├── pages/           # Page components
│   │   ├── services/        # API services
│   │   ├── locales/         # Translation files
│   │   └── utils/           # Utility functions
│   └── public/
├── backend/                  # AWS Lambda functions
│   ├── functions/
│   │   ├── transcribe-handler/
│   │   ├── ai-analysis/
│   │   ├── task-assignment/
│   │   ├── notification-handler/
│   │   └── api-handlers/
│   └── shared/              # Shared utilities
├── infrastructure/           # AWS CDK infrastructure code
│   └── lib/
└── docs/                    # Documentation

• Node.js 18+ and npm
• Python 3.11+
• AWS Account with appropriate permissions
• AWS CLI configured
• AWS CDK installed (npm install -g aws-cdk)
• AWS Amplify CLI installed (npm install -g @aws-amplify/cli)

# Clone the repository
cd CareCircle

# Install all dependencies at once
npm run install:all

# Or install individually:
cd frontend && npm install
cd ../backend && pip install -r requirements.txt
cd ../infrastructure && npm install

aws configure
# Enter your AWS Access Key ID, Secret Access Key, and default region (us-east-1 recommended)

cd infrastructure

# Bootstrap CDK (first time only)
cdk bootstrap

# Deploy the stack
cdk deploy

# Save the outputs (UserPoolId, UserPoolClientId, APIEndpoint)

Update frontend/src/aws-exports.js with the CDK outputs, or create a .env file:

cd frontend
cat > .env << EOF
REACT_APP_AWS_REGION=us-east-1
REACT_APP_USER_POOL_ID=your_user_pool_id_from_cdk_output
REACT_APP_USER_POOL_CLIENT_ID=your_client_id_from_cdk_output
REACT_APP_API_ENDPOINT=your_api_endpoint_from_cdk_output
EOF

Production note: never ship REACT_APP_API_ENDPOINT=http://localhost:3002 in hosted builds. Use your deployed API Gateway endpoint (for this environment: https://gb1jhkkzl2.execute-api.us-east-1.amazonaws.com/prod).

cd frontend

# Initialize Amplify
amplify init
# Follow prompts: project name, environment, use AWS profile

# Add hosting
amplify add hosting
# Choose: Hosting with Amplify Console, Manual deployment

# Publish
amplify publish

# Frontend
cd frontend
npm start
# Visit http://localhost:3001

# Backend (using SAM CLI)
cd backend
sam local start-api

In AWS Console:

1. Go to Amazon Bedrock
2. Click "Model access"
3. Request access to "Claude 3 Haiku"
4. Wait for approval (usually instant)

aws ses verify-email-identity --email-address noreply@yourdomain.com
# Check email and click verification link

For detailed instructions, see:

• Architecture + implementation: this README.md
• Kiro development narrative: KIRO_DEVELOPMENT_CASE_STUDY.md
• Kiro specs: .kiro/specs/care-operations-console/
• Deployed app walkthrough: docs/DEPLOYED_APP_NAVIGATION_FUNCTIONAL_GUIDE.md

This project was developed using AWS Kiro, the AI-powered IDE, to:

• Generate infrastructure-as-code (AWS CDK)
• Create boilerplate Lambda functions
• Optimize code for AWS Free Tier limits
• Implement best practices for serverless architecture

CareCircle supports six languages:

• English (en)
• Spanish (es)
• Hindi (hi)
• Arabic (ar)
• Mandarin Chinese (zh)
• Portuguese (pt)

Translation files are located in frontend/src/locales/.

• User authentication via Amazon Cognito
• Data encrypted at rest (DynamoDB encryption)
• Data encrypted in transit (SSL/TLS)
• IAM roles with least privilege principle
• CloudWatch logging for audit trails

The platform is designed to operate within AWS Free Tier limits:

• Serverless architecture (pay only for usage)
• DynamoDB on-demand capacity
• Optimized Transcribe usage (short streams)
• Efficient Lambda execution (minimal compute time)
• CloudWatch metrics for cost monitoring

# Frontend tests
cd frontend
npm test

# Backend tests
cd backend
python -m pytest

# Deploy infrastructure
cd infrastructure
cdk deploy --all --context env=production

# Deploy frontend
cd ../frontend
amplify publish

The project includes AWS CodePipeline configuration for automated deployments.

Use seeded data from demo/seed-data.js and walk through the core flow: call intake -> AI triage -> task assignment -> family notifications.

CareCircle tracks:

• Task completion rates
• Response times (alert to task acceptance)
• Issue resolution effectiveness
• Caregiver workload distribution
• Behavioral drift trends

1. Freemium Model: Basic coordination free, premium AI monitoring $20/month
2. B2B2C Partnerships: Employee benefit programs, insurance companies
3. Healthcare Provider Licensing: Integration with EHR systems

Originally built in an AI Agents Week-long Hack with Kiro and now maintained as an evolving care coordination platform.

Copyright 2025. All rights reserved.

For support or collaboration inquiries, open an issue in this repository.