LifeOps

An autonomous personal-operations agent that turns everyday documents into actions—tracking subscriptions, warranties, renewals and appointments while keeping users in control.

Comment

Inspiration

Life admin is surprisingly fragmented.

A subscription invoice is in one place. A warranty is buried in a PDF. An appointment confirmation is somewhere else. A renewal date is approaching — and by the time we remember it, it may already be too late.

Most AI assistants are useful after you remember to ask them something.

I wanted to explore a different question:

What if AI could do more than answer questions about your life? What if it could safely help operate it?

That became LifeOps — an autonomous personal-operations agent designed to reduce the mental overhead of everyday administration for busy students, professionals, and households.

What it does

LifeOps turns everyday documents and information into persistent, actionable workflows.

Instead of stopping at:

"Here's what your document says."

LifeOps asks:

"What happened, what should happen next, am I allowed to do it, and what should I remember?"

For example, when a user provides a subscription invoice, LifeOps can securely store and analyze the document, understand what it represents, create an action plan, check the user's autonomy policy, execute permitted actions, and persist the result in the user's operational state.

The product includes:

  • Command Center — a dashboard showing what currently needs attention
  • Life Vault — structured records created from everyday documents
  • Timeline — persistent history of events and agent actions
  • Autonomy Center — user-controlled permissions for autonomous actions
  • Subscriptions, warranties, renewals, appointments and obligations
  • Notifications and scheduled reminders
  • Secure authentication and user-isolated data

At the center of LifeOps is a simple loop:

Observe → Understand → Plan → Guard → Act → Remember

The goal is to move from document intelligence to operational intelligence.

How we built it

LifeOps combines a Next.js product interface, a Python/FastAPI service layer, AWS document intelligence, persistent cloud state, and an independently deployed autonomous agent.

The autonomous workflow is built with the Strands Agents SDK and deployed to Amazon Bedrock AgentCore Runtime.

Rather than allowing one model call to decide everything, I separated the agent into four stages:

  1. Observer — determines what happened
  2. Planner — decides what should happen next
  3. Guardian — checks whether the proposed actions are permitted
  4. Executor — performs approved actions using LifeOps tools

Useful results are then persisted so future interactions can build on what LifeOps already knows.

The AWS architecture uses:

  • Amazon Bedrock for foundation model inference
  • Amazon Bedrock AgentCore Runtime for production agent execution
  • Amazon Bedrock AgentCore Memory for persistent agent context
  • Amazon Textract for document extraction
  • Amazon S3 for secure document storage
  • Amazon DynamoDB for persistent operational state
  • Amazon Cognito for authentication
  • Amazon EventBridge Scheduler + AWS Lambda for scheduled operations
  • Amazon CloudWatch for observability
  • AWS IAM for least-privilege access control

The frontend is built with Next.js, React, TypeScript and Tailwind CSS, while FastAPI, Python, Pydantic and boto3 power the service layer.

For production, the web application is deployed on Vercel, the FastAPI service on Render, and the autonomous agent on Amazon Bedrock AgentCore Runtime.

The production Vercel application authenticates to AWS using OIDC federation and temporary AWS credentials, rather than storing permanent AWS access keys.

Challenges we ran into

The hardest part wasn't getting an LLM to generate an answer.

It was designing a system that knows when it should act, when it should ask, how it should remember, and how to do all of that securely.

Some of the biggest challenges were:

  • designing category-specific autonomy controls
  • creating the Guardian permission boundary between proposed and permitted actions
  • moving from stateless AI conversations to persistent operational state
  • coordinating the Observer, Planner, Guardian and Executor
  • maintaining user isolation across Cognito, S3, AgentCore and DynamoDB
  • deploying the autonomous workflow to Amazon Bedrock AgentCore Runtime
  • configuring least-privilege IAM permissions across multiple runtime components
  • securely connecting a production Vercel deployment to AWS using OIDC
  • integrating S3, Textract, DynamoDB, Cognito, AgentCore, FastAPI and Next.js into one working system
  • making the entire product responsive and usable on mobile

LifeOps started as an AI project and quickly became a distributed-systems project wearing an AI hat.

Accomplishments that we're proud of

I'm particularly proud that LifeOps became more than a prototype UI around an LLM.

The final system has a working, independently deployed autonomous agent running on Amazon Bedrock AgentCore Runtime, connected to a production web application.

I'm also proud of the Guardian architecture. LifeOps doesn't treat every autonomous action equally. Users can independently configure areas of their operational life as:

  • Observe — understand and track, but don't act
  • Ask First — prepare the action and require approval
  • Automatic — execute approved low-risk actions autonomously

This creates a clear boundary between:

AI wants to do something

and:

AI is allowed to do something.

The production system also includes Cognito authentication, user-isolated S3 storage, persistent DynamoDB state, AgentCore Memory, OIDC-based AWS authentication, responsive mobile support, and a live deployed application.

Most importantly, the complete flow works end-to-end:

Document → Understand → Plan → Guard → Execute → Persist → Surface to the user

What we learned

Building LifeOps changed how I think about agentic AI.

At the beginning, my questions were mostly:

  • How do I call the model?
  • How do I write the prompt?
  • How do I extract the document?

They quickly became:

  • When should an agent act?
  • When should it ask?
  • How should it remember?
  • How do you prevent duplicate or unsafe actions?
  • How should services authenticate with each other?
  • What permissions should each component receive?
  • How do you isolate one user's agent state from another?
  • How do you turn an agent demo into a production system?

The biggest lesson was that building a useful autonomous agent isn't just about making the model more capable.

It's about building the infrastructure around the model that determines what it knows, what it remembers, what tools it can use, and when it is allowed to use them.

LifeOps taught me as much about cloud architecture, security, IAM, distributed systems, API design, state management and product thinking as it did about generative AI.

What's next for LifeOps

LifeOps is currently a working production prototype, but the broader idea can go much further.

Next, I'd like to explore:

  • email and inbox ingestion for automatic life-event detection
  • calendar integration
  • richer subscription change intelligence
  • proactive warranty and renewal monitoring
  • additional user-controlled agent tools
  • richer long-term AgentCore Memory
  • improved approval workflows for sensitive actions
  • integrations with more of the services people already use for everyday administration

The long-term vision is for LifeOps to quietly handle more of the operational overhead of everyday life while keeping the user in control of every meaningful decision.

Not just an AI that knows things about your life — an AI that can safely help operate it.

Built With

Share this project:

Updates

Submission history