Mersad AI

From a WhatsApp report to accountable action — Mersad uses Agentic AI to understand, assign, track, escalate, and verify every operational incident.

Comment

Mersad

Inspiration

Operational and HSE incidents often start with something simple: a WhatsApp message, a photo, or a verbal observation.

The difficult part is what happens after the report is received:

  • Who owns the issue?
  • How critical is it?
  • Which policy applies?
  • Has the corrective action been completed?
  • Has the deadline passed?
  • Is there evidence proving that the issue was actually resolved?

In many real-world environments, these answers are spread across disconnected conversations, forms, spreadsheets, and manual follow-ups. This creates delays, unclear ownership, inconsistent escalation, and limited auditability.

We built Mersad to transform this fragmented process into one measurable operational journey:

Report → Understand → Classify → Assign → Act → Follow Up → Verify → Close

Our goal was to make WhatsApp a real operational interface connected directly to an accountable enterprise workflow rather than treating communication as a separate layer.

What Mersad Does

Mersad is an Agentic AI-powered operational incident and action management platform that connects field reporting, AI analysis, classification, risk assessment, policy matching, assignment, communication, task execution, follow-up, escalation, evidence, human review, and verified closure.

Users can submit incidents through the web or directly through WhatsApp using text, images, and attachments.

When a report arrives, Mersad:

  • Creates or links it to a structured event.
  • Uses AI to summarize the incident and identify missing information.
  • Recommends the event type and severity.
  • Identifies urgent actions.
  • Matches the incident with the appropriate HSE policy or operational role.
  • Recommends an eligible owner based on team, site, skills, and availability.
  • Creates an actionable task with a deadline.
  • Sends updates and actions through WhatsApp.
  • Manages reminders and escalation.
  • Collects completion evidence.
  • Routes sensitive decisions to authorized human reviewers when required.
  • Maintains a complete audit trail until verified closure.

The result is a clear transition from fragmented communication to:

A structured event, a clear owner, a defined deadline, and verifiable closure.

Why WhatsApp?

One of our main design decisions was to bring the operational workflow to the communication channel that field workers and supervisors already use.

Instead of forcing users to constantly open another application, WhatsApp becomes part of the workflow itself.

Users can:

  • Report incidents.
  • Send images and evidence.
  • Answer clarification questions.
  • Receive assigned actions.
  • Acknowledge tasks.
  • Request support.
  • Receive reminders.
  • Interact with escalation workflows directly from the conversation.

At the same time, every interaction remains connected to the same structured event and task record inside Mersad instead of becoming another isolated conversation.

How We Built It

Mersad runs on AWS using an event-driven, cloud-native architecture designed for enterprise operations.

The main application workloads run on Amazon EKS, with separate Kubernetes workloads for the Next.js web application, FastAPI backend, and asynchronous worker.

The platform uses:

  • AWS End User Messaging Social and WhatsApp for field communication.
  • Amazon Bedrock for AI inference.
  • Amazon Bedrock AgentCore Runtime to orchestrate the agentic workflow.
  • AgentCore Gateway for controlled access to approved operational tools and data.
  • Amazon DynamoDB for events, tasks, policies, operational directories, and workflow state.
  • Amazon S3 for incident evidence, images, and attachments.
  • Amazon SQS for asynchronous processing, retries, and workload decoupling.
  • Amazon EventBridge Scheduler for task deadlines, reminders, and escalation timing.
  • Amazon SNS and AWS Lambda for communication events and inbound WhatsApp processing.
  • Amazon Cognito for authentication, MFA, and role-based access.
  • Amazon CloudFront and Elastic Load Balancing for secure application delivery and traffic routing.
  • Amazon CloudWatch for logs, metrics, dashboards, and operational monitoring.
  • AWS IAM, AWS KMS, AWS CloudTrail, and Amazon GuardDuty for access control, encryption, auditing, and security monitoring.

Agentic AI Workflow

Rather than asking one model to make every operational decision, Mersad separates responsibilities across specialized AI agents.

Intake Agent

The Intake Agent summarizes the report, identifies missing information, and checks for possible duplicates.

Triage and Risk Agent

The Triage and Risk Agent recommends:

  • Event category.
  • Severity.
  • Risk rationale.
  • Immediate containment action.
  • Whether human review is required.

Assignment and Communication Agent

The Assignment and Communication Agent recommends an eligible team or team member using real operational information such as:

  • Skills.
  • Site.
  • Responsibility.
  • Availability.

Follow-up Agent

The Follow-up Agent recommends:

  • Follow-up timing.
  • Required completion evidence.
  • Escalation conditions.
  • Closure requirements.

These roles operate within one controlled Amazon Bedrock AgentCore workflow.

Human-in-the-Loop by Design

Mersad does not give AI unrestricted authority over operational decisions.

AI can analyze information and recommend actions, but consequential changes are validated by the application before they are committed.

The backend revalidates:

  • Authorization.
  • User permissions.
  • Current event state.
  • Policies.
  • Team eligibility.
  • Assignment rules.
  • Closure requirements.

Low-confidence decisions, sensitive cases, policy exceptions, and governed closure actions can be routed to an authorized human reviewer.

AI assists the decision. Operational authority remains governed by policy, permissions, and people.

Event-Driven Processing

Another major architectural decision was separating user-facing requests from longer-running AI and communication processing.

When a report arrives:

  • The application validates and stores the required state.
  • A work reference is sent to Amazon SQS.
  • Workers process the job asynchronously.
  • AgentCore performs the required AI workflow.
  • Evidence is retrieved from Amazon S3 when needed.
  • Results are written back to DynamoDB.
  • Messages and actions are sent through WhatsApp.

This architecture keeps the reporting experience responsive while supporting reliable background processing.

Deadlines, Follow-up, and Escalation

For operational deadlines, Amazon EventBridge Scheduler manages timing while the Mersad worker owns the business decision.

When a deadline is reached, the worker checks the latest task state before deciding whether a reminder or escalation should actually happen.

This is important because a task may already have been:

  • Completed.
  • Reassigned.
  • Declined.
  • Escalated.
  • Submitted for approval.

The system therefore avoids sending outdated reminders or continuing an escalation chain that is no longer valid.

Evidence and Visual Analysis

Mersad supports incident evidence such as images and documents.

Visual evidence can be analyzed through Amazon Bedrock to help identify:

  • What is visible in the evidence.
  • Possible hazards.
  • Incident type.
  • Risk level.
  • Suggested containment actions.
  • Potential policy relevance.

The analysis remains linked to the original event so evidence, AI reasoning, assignment, actions, communication, and closure history remain part of the same operational record.

Challenges We Faced

Turning Unstructured WhatsApp Messages Into Structured Operational Data

One of the first challenges was turning unstructured WhatsApp messages into structured operational data.

Real incident reports are rarely clean or complete. A worker may send only a short sentence, an image, or a message without location, severity, or enough context.

We had to design a workflow that could understand incomplete information, identify what was missing, request clarification when necessary, and gradually transform the conversation into a structured event without making the reporting process difficult for the user.

AI Recommendations vs. Operational Authority

Another major challenge was defining the boundary between AI recommendations and operational authority.

It would have been technically possible to let an LLM automatically assign users, confirm violations, escalate incidents, or close cases.

Instead, we designed Mersad around Human-in-the-Loop Agentic AI.

The AI assists with understanding and recommendations, while the backend remains responsible for permissions, policy enforcement, validation, and consequential state changes.

Connecting Communication to Workflow State

Connecting communication to workflow state was another important challenge.

WhatsApp is not treated as an external notification channel.

Inbound messages, interactive replies, delivery status, task actions, and escalation must all map back to the correct event or task.

Maintaining that relationship required:

  • Stable identifiers.
  • Correlation IDs.
  • Message normalization.
  • Idempotency controls.
  • Asynchronous processing.

Reliable Follow-up and Escalation

Reliable follow-up and escalation also required careful design.

Tasks may already be completed, reassigned, declined, or awaiting approval by the time a scheduled reminder fires.

We therefore separated scheduling from business logic.

EventBridge manages timing, while the worker checks the latest task state before taking action.

Production-Grade AWS Deployment

Finally, deploying the platform as a production-grade AWS architecture required coordinating:

  • Kubernetes workloads.
  • Serverless ingestion components.
  • Queues.
  • Databases.
  • Object storage.
  • Identity services.
  • AI infrastructure.
  • Communication services.
  • Security services.
  • Observability.

At the same time, the architecture needed to maintain least-privilege access between the API, workers, AI runtime, and operational tools.

What We Learned

One of the most important lessons was that successful enterprise Agentic AI is not only about model intelligence.

The real value comes from combining AI reasoning with:

  • Controlled tools.
  • Trusted operational data.
  • Explicit permissions.
  • Deterministic business rules.
  • Asynchronous workflows.
  • Human approval gates.
  • Auditability.
  • Reliable communication.

We also learned that communication itself can become part of the application architecture.

By connecting WhatsApp directly to the same event, task, policy, assignment, and escalation engine used by the web platform, field communication becomes structured operational data instead of disappearing inside disconnected conversations.

Another important lesson was that an AI agent does not need unrestricted write access to be useful.

Keeping AgentCore tools controlled while allowing the application to validate and execute approved actions created a much clearer enterprise security and governance boundary.

What We Are Most Proud Of

Mersad brings communication, Agentic AI, operational policies, ownership, deadlines, escalation, evidence, and human approval together in one end-to-end operational platform.

A report can begin as a simple WhatsApp message and become a fully traceable operational record containing:

  • What happened.
  • How it was classified.
  • How critical it is.
  • Which policy applies.
  • Who became responsible.
  • What action was required.
  • When it was due.
  • How the system followed up.
  • What evidence was submitted.
  • Which decisions required human review.
  • How the case was finally closed.

The platform keeps the entire lifecycle measurable, reviewable, and auditable from the first report to verified closure.

Mersad shows how AWS Communication Developer Services, Amazon Bedrock AgentCore, and enterprise workflow orchestration can operate together as one operational system rather than as disconnected communication and AI components.

What's Next

The architecture was intentionally designed so the same operational engine can expand beyond HSE.

The same reporting, Agentic AI, assignment, task, escalation, evidence, and closure workflow can support:

  • Operations.
  • Facilities.
  • Quality.
  • Maintenance.
  • Compliance.
  • Field Service.

Our next goal is to continue expanding:

  • Policy-aware automation.
  • Operational intelligence.
  • Management analytics.
  • Enterprise integrations.
  • Multi-site operations.
  • Advanced agent capabilities.

while keeping Mersad's core principle unchanged:

AI accelerates operational decisions, while policies, permissions, accountability, and human control remain at the center of the system.

Built With

  • agentic-ai
  • amazon-bedrock
  • amazon-bedrock-agentcore
  • amazon-cloudwatch
  • amazon-cognito
  • amazon-eks
  • amazon-eventbridge
  • amazon-sns
  • amazon-sqs
  • amazon-web-services
  • aws-end-user-messaging-social
  • aws-iam
  • aws-kms
  • aws-lambda
  • cloudfront
  • dynamodb
  • fastapi
  • generative-ai
  • hse
  • human-in-the-loop
  • incident-management
  • kubernetes
  • nextjs
  • whatsapp
Share this project:

Updates

Submission history