AWS Builder Center
LifeOps: From Human-Assisted Digital Services to an Agentic Digital Worker

LifeOps: From Human-Assisted Digital Services to an Agentic Digital Worker

LifeOps is a general-purpose agentic digital worker that turns a user's goal into real digital action—discovering services, navigating websites, handling documents and task state, and involving the user when approval or authentication is required.

AWS SBG lead kerala,founded first aws sbg @kerala,first & only aws cloud captain @kerala
LifeOps: From Human-Assisted Digital Services to an Agentic Digital Worker

What if getting things done online was as simple as asking someone for help?

In Kerala, digital services are everywhere.
Government applications, certificates, hospital appointments, scholarships, utility payments, registrations, educational services, and countless other processes have moved online.
But there is a problem.
Going digital does not automatically make something accessible.
For someone who is comfortable with technology, visiting a portal, finding the correct service, filling a form, uploading documents, handling authentication, and submitting an application may take only a few minutes.
For someone who isn't digitally confident, the same process can become overwhelming.
That is where human-assisted digital services have played an important role.
And that is where the idea for LifeOps began.



The Inspiration

Growing up in Kerala, I have seen how people who are not comfortable with digital systems can struggle with online processes.
My mother and grandmother are examples of the kind of people who can find digital processes difficult—not because they don't know what they need, but because the digital process itself becomes a barrier.
They may know:
"I need to apply for this certificate."
or
"I need to book this appointment."
or
"I need to submit this application."
But then comes the difficult part:
Which website?
Which service?
Which form?
Which documents?
Which fields?
What should I do next?
Human-assisted digital service centres provide a bridge between the person and the digital service.
The person requesting the service doesn't necessarily need to understand every technical detail behind the process.
That experience made me think:
What if we could build a digital worker that provides the same kind of assistance—using AI?
Not another chatbot.
Not another website that tells people where to click.
A system that could actually do the digital work.
That idea became LifeOps.



What is LifeOps?

LifeOps is a general-purpose agentic digital worker.
The idea is simple:
Tell LifeOps what you need. It handles the digital work. You keep the final word.
Instead of asking a user to understand an entire digital workflow, LifeOps starts from the user's goal.
For example:
"Book an appointment at District Hospital Kanhangad for tomorrow."
The user doesn't have to specify:
  • Which website
  • Which portal
  • Which page
  • Which fields
  • Which documents
  • Which sequence of actions
LifeOps is designed to figure out the digital workflow.



From Human Assistance to AI Assistance

A human-assisted digital service essentially creates a bridge:
Person
↓
Human assistance
↓
Digital service
LifeOps explores a similar model:
Person
↓
AI digital worker
↓
Digital service
But there is one major difference.
A human operator can understand the context of a situation naturally.
An AI agent needs an architecture that allows it to:
  • Understand the goal
  • Discover services
  • Discover requirements
  • Use tools
  • Navigate websites
  • Remember state
  • Handle documents
  • Ask questions
  • Pause when necessary
  • Request approval
  • Resume work
  • Verify completion
That became the engineering challenge behind LifeOps.



The Core Philosophy

LifeOps is built around one principle:

Users should describe the outcome, not the procedure.

Traditional digital systems often expect users to understand the procedure first:
Know the website
→ Know the service
→ Know the form
→ Know the fields
→ Complete the workflow
LifeOps reverses that:
Know what you want
↓
Tell LifeOps
↓
LifeOps figures out the digital process
The goal is to make the technology adapt to the person rather than forcing the person to become an expert in every digital system.



LifeOps Product Features

LifeOps is not only an AI agent running in the background.
It is a complete workspace where users can create, monitor, organize, and safely complete their digital tasks.
The application is organized into several interconnected areas.


1. Sign In
















LifeOps uses authenticated user accounts so that each person's tasks, documents, notifications, planner items, and activity remain associated with their own identity.
Authentication is handled using Amazon Cognito.
After signing in, the user gets access to their personal LifeOps workspace.
The authentication system is designed around:
  • Secure user identity
  • Authenticated API requests
  • User-specific task ownership
  • User-specific document access
  • User-specific planner data
  • User-specific notifications
  • User-specific activity
LifeOps does not rely on the frontend simply claiming which user is making a request. The backend uses the authenticated identity to enforce ownership.


2. Home






The Home page is the central workspace of LifeOps.
It combines the AI task creation experience with an overview of the user's current work.
The user can simply describe what needs to get done in natural language.
For example:
"Please take a general OP from District Hospital Kanhangad tomorrow."
The Home page contains several important capabilities.

Create a Task

The user describes the goal in plain words.
There is also an optional Target Website field when the user already knows which service should be used.
LifeOps then creates the task and begins planning the digital workflow.
The user does not need to explain every step.



Daily Planner

The Home page also contains a Daily Planner.
Users can add everyday tasks with:
  • Task title
  • Deadline
  • Completion status
For example:
Gate registration — 12:00 PM
Tasks can be marked as completed, and completion persists rather than disappearing after a refresh.


Task Status Overview




The Home page provides an overview of the user's active work.
The dashboard shows task states such as:
  • Needs approval
  • Needs you
  • Working
  • Finished
  • Total tasks
This gives the user an immediate understanding of what requires attention.



Recent Tasks

The Home page also provides a Recent Tasks section.
Instead of searching through the entire application, users can quickly access recently created tasks and continue where they left off.


3. Tasks Page




The Tasks page provides a centralized view of all LifeOps tasks.
Users can filter tasks based on their current state.
Available views include:
  • All
  • Approval needed
  • Needs you
  • Working
  • Finished
This is especially important for an agentic system because a task may not always be completed immediately.
A task might move through:
Working
↓
Needs you
↓
Waiting for approval
↓
Working
↓
Finished
The Tasks page makes these states visible to the user.



Task Workspace

Each task gets its own workspace.
The workspace can contain:
  • Task description
  • Conversation
  • Execution plan
  • Agent activity
  • Current status
  • Waiting states
  • Approval requests
  • Authentication checkpoints
  • Evidence
  • Completion information
This makes the agent's actions understandable instead of turning the process into a black box.
The user can see not only what they asked LifeOps to do, but also where the task currently stands.


4. Calendar Page




The Calendar page provides a date-based view of planner tasks.
Users can navigate between dates and see the tasks associated with each day.
Each task can show:
  • Task title
  • Deadline
  • Completion status
The selected date provides a focused view of what needs to be done on that day.
The Calendar is intentionally separate from the AI execution engine.
It is a productivity layer that helps users organize their everyday responsibilities.


5. Notification Page




The Notifications page keeps users informed when something requires attention.
LifeOps can generate notifications for:
  • Upcoming tasks
  • Overdue tasks
  • Completed tasks
  • Agent tasks requiring input
  • Missing documents
  • Approval requirements
  • Authentication requirements
For example:
"Gate registration" was due at 12:00 PM and is still incomplete.
Notifications include:
  • Notification type
  • Message
  • Timestamp
  • Read/unread state
Users can also mark notifications as read.
The system uses notification deduplication so the same event does not repeatedly generate identical alerts.


6. Digital Locker Page




The Digital Locker provides a secure place for users to store documents that may be needed for future digital tasks.
Users can upload documents such as:
  • Aadhaar
  • PAN
  • Voter ID
  • Ration Card
  • Educational certificates
  • Income certificates
  • Caste certificates
  • Residence certificates
  • Bank documents
  • Passport
  • Photographs
Documents can be associated with a task when necessary.
The Locker can maintain metadata such as:
document_id
user_id
filename
document_type
MIME type
upload timestamp
issuing authority
issue date
expiry date
verification status
S3 object reference
The goal is not to blindly send complete documents to an AI model.
Where possible, LifeOps can use document metadata to determine whether an appropriate document is already available.
Documents are stored in Amazon S3, while ownership and application metadata are protected through authenticated user identity.


7. Activity Page




The Activity page provides visibility into what has happened inside LifeOps.
An agentic application performs many operations in the background, so users need a way to understand the system's actions.
Activity can provide visibility into:
  • Task creation
  • Planning
  • Agent execution
  • Browser activity
  • User input
  • Approval requests
  • Authentication checkpoints
  • Task completion
  • Errors and recovery
This creates an auditable trail around agent activity.
Instead of simply saying:
"The AI did something."
LifeOps provides a clearer picture of the task lifecycle.


8. Settings Page

The Settings page provides controls for the user's LifeOps experience.
It contains several configuration areas.
Appearance Toggle




LifeOps provides two appearance modes.

Default

The default interface uses a dark, professional visual style with:
  • Deep zinc backgrounds
  • Blue accents
  • Rounded cards
  • Subtle borders
  • Soft gradients
  • Agentic workspace styling
This is the primary working configuration.

Aesthetic

The Aesthetic mode provides a softer visual experience using:
  • Cream
  • Warm beige
  • Pink
  • Blush
  • Peach
  • Lavender
  • Mint
  • Sky blue
  • Softer rounded surfaces
The user can toggle between Default and Aesthetic without changing the underlying task or agent functionality.



Notification Settings

Settings also provides notification-related controls.
Users can see whether desktop notifications are enabled and manage notification behavior from the application.
The notifications are designed to bring the user's attention to situations where LifeOps actually needs them.



LifeOps Services

The Settings page also provides visibility into the availability of LifeOps services.
This separates the user's application preferences from the underlying agent and backend services.



The LifeOps Agent Loop

The product interface is only one part of LifeOps.
Behind it is a general agent architecture.
The agent follows this lifecycle:
GOAL
↓
UNDERSTAND
↓
DISCOVER SERVICE
↓
DISCOVER REQUIREMENTS
↓
CHECK DIGITAL LOCKER
↓
REQUEST MISSING INFORMATION
↓
PLAN
↓
EXECUTE
↓
OBSERVE
↓
DECIDE
↓
HUMAN INPUT
↓
TRUST GATE
↓
AUTHENTICATION BOUNDARY
↓
RESUME
↓
VERIFY
↓
COMPLETE
This is deliberately not a collection of hardcoded bots.
It is a general agent architecture.



1. Goal Understanding

Everything starts with the user's request.
For example:
"I need an appointment at District Hospital Kanhangad tomorrow."
LifeOps needs to understand:
  • What does the user want?
  • Where?
  • When?
  • What type of service?
  • What information is already available?
  • What information is missing?
The user should not have to translate their request into machine-specific instructions.



2. Service Discovery

Once the goal is understood, LifeOps determines which digital service is relevant.
For the demonstration, the target service is Kerala eHealth:
The important architectural principle is that the hospital workflow is not supposed to become a separate hospital-specific agent.
Instead:
User Goal
↓
Service Discovery
↓
Selected Service
↓
Browser Execution
This makes the system extensible to other digital services.



3. Requirement Discovery

Finding the website is only the beginning.
The agent also needs to understand what the service requires.
For example:
  • Patient information
  • Hospital
  • Department
  • Date
  • Appointment details
  • Required documents
If information is missing, LifeOps should ask the user rather than invent it.



4. Digital Locker Intelligence

Instead of repeatedly uploading documents for different tasks, LifeOps can maintain a secure document repository.
The agent can check whether a required document already exists.
The important principle is:
Use the information needed for the task rather than blindly sending complete documents to the AI model.
This creates a bridge between the Digital Locker and the agentic workflow.



5. Task-Specific Workspace

Every task gets its own workspace.
Instead of mixing every conversation together, the user can see:
  • Task status
  • Conversation
  • Execution plan
  • Agent activity
  • Waiting states
  • Approval requests
  • Authentication checkpoints
  • Evidence
  • Completion status
This makes the agent's actions understandable instead of turning the process into a black box.



6. Persistent Task State

An agent cannot assume that everything will happen in one uninterrupted session.
A task can become:
CREATED
PLANNING
RUNNING
WAITING_FOR_USER
WAITING_FOR_DOCUMENT
WAITING_FOR_APPROVAL
AUTHENTICATION_REQUIRED
COMPLETED
FAILED
STOPPED
For example:
RUNNING
↓
WAITING_FOR_USER
↓
User responds
↓
RUNNING
↓
WAITING_FOR_APPROVAL
↓
User approves
↓
RUNNING
↓
COMPLETED
The task resumes from its checkpoint instead of starting again.



7. Browser Automation

This is where LifeOps moves beyond a normal chatbot.
The browser agent uses:
OBSERVE → DECIDE → EXECUTE → OBSERVE
It does not simply generate instructions for the user.
It interacts with the website.
For the demo, LifeOps uses:
The browser can:
  • Open pages
  • Inspect page content
  • Identify relevant controls
  • Navigate
  • Fill safe fields
  • Observe changes
  • Continue based on the current page state.



8. Trust Gate

Automation becomes especially important when actions have consequences.
LifeOps therefore introduces a Trust Gate.
Before a consequential action, the agent stops:
Agent prepares action
↓
TRUST GATE
↓
User reviews
↓
Approve
↓
Agent resumes
This means the agent can do the repetitive digital work while the user retains control over important decisions.



9. Authentication Boundary

LifeOps does not try to bypass:
  • OTP
  • Passwords
  • MFA
  • CAPTCHA
  • Biometrics
  • Other authentication mechanisms
Instead:
Agent
↓
Authentication required
↓
Task pauses
↓
User authenticates
↓
Task resumes
This creates a clear boundary between agent automation and user-controlled authentication.



10. Verification

One of the most important principles in LifeOps is:
Performing an action is not the same as completing a task.
If an agent clicks a button, that doesn't necessarily mean the appointment was created.
The system should verify the result.
Only after successful verification should the task become:
COMPLETED



11. Safety Against Webpage Prompt Injection

A website is not a trusted source of instructions for the agent.
Webpages can contain malicious text designed to manipulate an AI agent.
LifeOps therefore treats webpage content as untrusted input.
The agent's core instructions, security boundaries, and user permissions remain separate from instructions contained inside arbitrary webpage content.



12. SSRF Protection

An agent that can access URLs introduces another security concern:
What URLs should it be allowed to access?
LifeOps includes SSRF protection around URL handling so that user-controlled or discovered URLs are not blindly trusted.
This is particularly important when an application gives an AI-controlled browser access to the network.



13. Planner

LifeOps also includes a separate Daily Planner.
Users can create tasks with:
  • Task title
  • Date
  • Deadline
  • Completion status
The planner persists task completion rather than relying only on browser state.
Completed tasks remain available for history.



14. Calendar

The planner connects with a separate calendar view.
Users can navigate dates and see:
  • Task title
  • Deadline
  • Completion status
The calendar is designed as a productivity feature and is kept separate from the AI execution engine.



15. Deadline Notifications

LifeOps can track deadlines and generate notifications for:
  • Upcoming tasks
  • Overdue tasks
  • Completed tasks
The system also uses deduplication so the same deadline does not repeatedly generate identical notifications.



16. Notification Types for Agent Tasks

Agent-related notifications can include:
TASK_NEEDS_INPUT
TASK_NEEDS_DOCUMENT
TASK_NEEDS_APPROVAL
AUTHENTICATION_REQUIRED
TASK_COMPLETED
TASK_FAILED
This means the user does not need to continuously watch the agent.
The system can tell them when their attention is actually needed.


17. Chrome Extension
















LifeOps also includes a lightweight browser extension.
The idea is:
Current webpage
↓
LifeOps Extension
↓
Create LifeOps task
↓
Agent
A user can capture the current webpage and send it into LifeOps rather than manually copying the URL.
The extension does not contain the AI agent.
It acts as a bridge into the LifeOps task system.



18. Authentication and User Isolation

LifeOps uses authenticated user identity to isolate user data.
Tasks, documents, messages, planner items, and notifications belong to the authenticated user.
This is critical because an agentic application should never rely on the frontend simply claiming:
"I am user X."
The backend must establish ownership from the authenticated identity.



Part 2 — Building LifeOps with AWS

The conceptual system becomes a production cloud architecture.
USER
│
▼
AWS Amplify
Frontend
│
▼
Amazon Cognito
Authentication
│
▼
Application Load Balancer
│
▼
ECS + Fargate
│
┌─────────────┼─────────────┐
│ │ │
▼ ▼ ▼
Bedrock DynamoDB S3
/ Nova Task State Digital Locker
│
▼
Agent Orchestrator
│
▼
Browser Automation
│
▼
External Services



Amazon Bedrock

Amazon Bedrock provides the foundation model layer for LifeOps.
The model is responsible for reasoning about:
  • User intent
  • Task context
  • Available information
  • Next actions
  • Tool usage
But Bedrock is not the entire agent.
The application controls the execution loop and safety boundaries.
Conceptually:
Goal
↓
Agent
↓
Amazon Bedrock
↓
Decision
↓
Tool
↓
Observation
↓
Amazon Bedrock



Amazon ECS and AWS Fargate

The LifeOps backend and agent runtime are containerized.
They run using:
Amazon ECS with AWS Fargate.
This provides the production runtime for the backend without requiring us to manage the underlying servers.



Amazon ECR

The application container is stored in:
Amazon Elastic Container Registry (Amazon ECR).
The deployment pipeline is:
Source Code
↓
Docker Image
↓
Amazon ECR
↓
Amazon ECS
↓
AWS Fargate



Amazon DynamoDB

DynamoDB provides persistent application state.
It can store:
  • Tasks
  • Task state
  • Checkpoints
  • Messages
  • Events
  • Planner tasks
  • Notifications
  • User-associated records
This persistent state is what allows LifeOps to pause and resume work.



Amazon S3

Amazon S3 provides object storage for the Digital Locker.
Documents are stored separately from the agent's task state, with controlled access based on authenticated ownership.



Amazon Cognito

Amazon Cognito handles authentication.
The identity established by Cognito is then used by the backend to enforce ownership across the application.
This protects:
  • Tasks
  • Documents
  • Chat
  • Planner
  • Notifications
  • Agent state



AWS Amplify

AWS Amplify hosts the LifeOps frontend and provides the public web application entry point.
The architecture becomes:
Browser
↓
Amplify
↓
LifeOps Frontend
↓
Production API
↓
ECS/Fargate



Application Load Balancer

The Application Load Balancer provides the public route into the backend service:
Internet
↓
ALB
↓
ECS Service
↓
Fargate
↓
LifeOps API



Why AWS Matters to LifeOps

AWS is not simply being used as infrastructure around the project.
Different AWS services have different responsibilities:
Requirement
AWS service
AI/model layer
Amazon Bedrock
Backend runtime
Amazon ECS + AWS Fargate
Container registry
Amazon ECR
Persistent state
Amazon DynamoDB
Document storage
Amazon S3
Authentication
Amazon Cognito
Frontend hosting
AWS Amplify
Public backend routing
Application Load Balancer
This separation allows each component to focus on a specific responsibility.

AWS Architecture and Cost Considerations

LifeOps was designed to use managed AWS services so that infrastructure could scale with the application without requiring dedicated servers.
For the backend, Amazon ECS with AWS Fargate avoids managing underlying servers, while Amazon ECR provides container storage. Amazon DynamoDB is used for persistent task and agent state, and Amazon S3 provides object storage for the Digital Locker.
The architecture also separates responsibilities between Amazon Bedrock, ECS/Fargate, DynamoDB, S3, Cognito, Amplify, ALB, and CloudFront, rather than running everything on a continuously provisioned server.
For a hackathon deployment, cost awareness is important. The system avoids unnecessary always-on infrastructure where possible, keeps persistent data in managed services, and uses the smallest practical architecture needed for the working product. We also avoided provisioning services simply to satisfy a checklist when they were not required by the application.
A key lesson was that cloud architecture is not only about making a system work—it is also about choosing the right managed services and understanding the cost implications of those choices.



What Makes LifeOps Different?

LifeOps is not intended to be:

A chatbot

It doesn't stop at answering questions.

A single-purpose hospital bot

The hospital appointment is a demonstration of a broader architecture.

A collection of hardcoded workflows

The goal is for the agent to reason from the user's goal and interact with services dynamically.

A generic AI wrapper

The application includes:
  • Persistent state
  • Browser tools
  • Security boundaries
  • Authentication handling
  • Documents
  • Human approval
  • Verification
  • Recovery



The Bigger Vision

The long-term idea behind LifeOps is inspired by the role of human-assisted digital service centres.
Imagine replacing:
"I don't know how to use this website."

"I need to find someone who can help me."

"I don't know which document they need."

"I don't know what to click."
with:
"I need this done."
↓
LifeOps understands.
↓
LifeOps finds the service.
↓
LifeOps performs the digital work.
↓
LifeOps asks when human input is required.
↓
LifeOps verifies completion.
↓
Done.
The technology should adapt to the person.
The person shouldn't have to become an expert in every digital system they need to use.



What I Learned Building an Agentic System

The biggest lesson from building LifeOps is that:
An AI model alone is not an agentic application.
A useful agent requires an ecosystem around the model.
I learned that reliable agentic systems require:

Reasoning

The model needs to understand the user's goal.

Tools

The agent needs ways to actually perform work.

State

The system needs to remember what happened.

Observation

The agent needs to understand the current environment.

Security

The agent must operate within strict boundaries.

Human Control

Users must remain involved in consequential decisions.

Verification

The system must confirm that the intended outcome actually occurred.

Recovery

The agent needs to pause and resume without losing the task.



The Vision Behind LifeOps

The inspiration came from a very human problem.
Technology is supposed to make life easier.
But sometimes, digital transformation simply moves the complexity from a physical office into a website.
Human-assisted digital services help bridge that gap for people.
LifeOps explores whether an AI digital worker can become another kind of bridge.
Not replacing people.
Not asking everyone to become technically skilled.
But making digital services feel more accessible.
The goal is not:
"Here is a website. Figure it out."
The goal is:
"Tell me what you need. I'll help you get it done."



LifeOps

Your tasks, done safely.
You tell LifeOps what needs to get done.
LifeOps handles the digital work.
You keep the final word.
Built with AWS for the WeMakeDevs × AWS First Commit / Bharat Builds Tour.



Team Leader's Contributions

For the hackathon submission:
Designed and built LifeOps end-to-end as the team leader. Responsible for product vision and architecture, agent orchestration, browser automation, service discovery, task state management, Trust Gate and human-in-the-loop flow, authentication boundaries, Digital Locker, planner/calendar/notifications, Chrome extension, security controls including SSRF and webpage prompt-injection protection, AWS architecture and deployment, frontend/backend integration, testing, debugging, and hackathon submission.



The final structure

This combined version now has both layers without dropping the content from either version:

LifeOps as a product

  1. Sign In
  1. Home
  • Create Task
  • Daily Planner
  • Task Status
  • Recent Tasks
  1. Tasks
  • Task Workspace
  1. Calendar
  1. Notifications
  1. Digital Locker
  1. Activity
  1. Settings
  • Appearance Toggle
  • Notification Settings
  • LifeOps Services

LifeOps as an agentic system

  1. Goal Understanding
  1. Service Discovery
  1. Requirement Discovery
  1. Digital Locker Intelligence
  1. Task-Specific Workspace
  1. Persistent Task State
  1. Browser Automation
  1. Trust Gate
  1. Authentication Boundary
  1. Verification
  1. Webpage Prompt Injection Protection
  1. SSRF Protection
  1. Planner
  1. Calendar
  1. Deadline Notifications
  1. Agent Notifications
  1. Chrome Extension
  1. Authentication & User Isolation
  1. AWS Architecture
  1. Lessons Learned
  1. Bigger Vision
So nothing from the two supplied versions has intentionally been removed; the overlapping sections have been merged rather than duplicated.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article