
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.
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 serviceLifeOps explores a similar model:
Person ↓AI digital worker ↓Digital serviceBut 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 workflowLifeOps reverses that:
Know what you want ↓Tell LifeOps ↓LifeOps figures out the digital processThe 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 ↓FinishedThe 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_iduser_idfilenamedocument_typeMIME typeupload timestampissuing authorityissue dateexpiry dateverification statusS3 object referenceThe 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 ↓COMPLETEThis 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 ExecutionThis 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:
CREATEDPLANNINGRUNNINGWAITING_FOR_USERWAITING_FOR_DOCUMENTWAITING_FOR_APPROVALAUTHENTICATION_REQUIREDCOMPLETEDFAILEDSTOPPEDFor example:
RUNNING ↓WAITING_FOR_USER ↓User responds ↓RUNNING ↓WAITING_FOR_APPROVAL ↓User approves ↓RUNNING ↓COMPLETEDThe 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 → OBSERVEIt 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 resumesThis 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 resumesThis 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_INPUTTASK_NEEDS_DOCUMENTTASK_NEEDS_APPROVALAUTHENTICATION_REQUIREDTASK_COMPLETEDTASK_FAILEDThis 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 ↓AgentA 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
- Sign In
- Home
- Create Task
- Daily Planner
- Task Status
- Recent Tasks
- Tasks
- Task Workspace
- Calendar
- Notifications
- Digital Locker
- Activity
- Settings
- Appearance Toggle
- Notification Settings
- LifeOps Services
LifeOps as an agentic system
- Goal Understanding
- Service Discovery
- Requirement Discovery
- Digital Locker Intelligence
- Task-Specific Workspace
- Persistent Task State
- Browser Automation
- Trust Gate
- Authentication Boundary
- Verification
- Webpage Prompt Injection Protection
- SSRF Protection
- Planner
- Calendar
- Deadline Notifications
- Agent Notifications
- Chrome Extension
- Authentication & User Isolation
- AWS Architecture
- Lessons Learned
- Bigger Vision
So nothing from the two supplied versions has intentionally been removed; the overlapping sections have been merged rather than duplicated.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article