LifeOps: Delegating Outcomes, Not Checklists

Repository: https://github.com/scha54/All-Things-Agentic-Hackathon

Technology Stack: Google ADK, Gemini API, Python, FastAPI, SQLite, React, TypeScript, Vite

Abstract

Most personal AI tools today operate as passive text synthesizers. When faced with a complex life event—such as relocating to a new apartment—users are forced to manage an exhausting checklist: reading contract terms, notifying utility vendors, scheduling installation technicians, reserving movers, updating addresses, and tracking deadlines.

LifeOps introduces a paradigm shift in personal software engineering: Outcome Delegation. Instead of prompting an assistant for step-by-step instructions, the user delegates a high-level outcome: "Sort out my broadband and apartment move situation." LifeOps autonomously investigates available documents, constructs a task dependency graph, executes low-risk background actions, pauses deterministically for human approval on high-risk operations, monitors progress asynchronously, and verifies completion against provider APIs.

This article details the design, agent hierarchy, risk guardrails, verification loops, and zero-cloud local deployment architecture of LifeOps.

1. The Architectural Shift: Chatbot vs. Autonomous Operations Agent

Traditional AI interactions follow a synchronous request-response loop:

CHATBOT PARADIGM:
User  ───►  Question ("How do I cancel my internet?")  ───►  LLM  ───►  Advice Text

LifeOps transforms this into an event-driven operational workflow:

LIFEOPS AUTONOMOUS PARADIGM:
User
 │
 ▼
Delegate Outcome ("Move my internet and apartment services")
 │
 ├──► Discovery Agent (Inspects lease & bill PDFs, extracts dates & policy constraints)
 ├──► Planning Agent (Constructs 7-step task dependency graph)
 ├──► Execution Agent (Submits utility notices, queries technician slots)
 ├──► Risk Engine (Pauses HIGH-risk booking for Human Approval)
 ├──► Verification Agent (Queries provider DB to confirm booking)
 ├──► Event Monitor (Detects vendor cancellation ──► Autonomously Replans ──► Rebooks)
 │
 ▼
✓ LIFE OPERATION RESOLVED

2. Multi-Agent Orchestration with Google ADK

LifeOps is engineered around the Google ADK (Agent Development Kit v2.3.0) framework. Rather than inflating agent counts for cosmetic appeal, every agent fulfills a distinct operational role:

flowchart TD
    User([User Outcome Input]) --> API[FastAPI Server]
    API --> Orchestrator[Orchestrator Agent]

    Orchestrator --> DB[(Local SQLite DB)]
    Orchestrator --> Discovery[Discovery Agent]
    Orchestrator --> Planner[Planning Agent]
    Orchestrator --> Execution[Execution Agent]

    Execution --> DocAgent[Document Agent]
    Execution --> ResearchAgent[Research Agent]
    Execution --> CommAgent[Communication Agent]

    Execution --> Verification[Verification Agent]

    Verification --> DB
    Orchestrator --> RiskEngine[Deterministic Risk Engine]
    RiskEngine --> ApprovalRequest{Human Sign-Off Needed?}
    ApprovalRequest -- Yes --> Pause[Pause & Queue Approval]
    Pause --> UI[Command Center UI]
    UI -- Approve --> Resume[Resume & Verify]

Specialist Agent Responsibilities:

1. Orchestrator Agent: Maintains overall workflow state, step transitions, risk evaluations, and paused state recovery.
2. Discovery Agent: Inspects local document vaults (current_lease.txt, new_lease.txt, internet_bill.txt, utility_bill.txt) and extracts structured facts with confidence ratings.
3. Planning Agent: Builds task graphs with explicit parent-child dependency bindings.
4. Execution Agent: Interacts with mock digital provider APIs.
5. Document Agent: Extracts lease dates, notice windows, and contract penalties.
6. Research Agent: Scans provider slots and compares pricing options.
7. Communication Agent: Drafts formal move-out notices and vendor emails (enforcing strict separation between DRAFT and SEND).
8. Verification Agent: Queries mock system databases to confirm outcome states rather than blindly trusting tool output.

3. Deterministic Safety: The Human-in-the-Loop Risk Engine

A major failure mode in modern agentic systems is allowing LLMs to execute irreversible financial or legal actions without boundary controls. LifeOps solves this by enforcing a deterministic, application-level Risk Engine:

When an action triggers HIGH or CRITICAL risk (or involves financial expenditure), LifeOps pauses the workflow, emits an APPROVAL_REQUESTED event, and presents a structured card to the user containing:

• What: The proposed action
• Cost: The financial commitment
• Why: Operational rationale
• Evidence: Document sources & quotes
• Controls: [Approve & Resume] or [Reject]

4. Asynchronous Resilience & Self-Healing Event Replanning

LifeOps state is stored in a local SQLite database (lifeops.db) configured with Write-Ahead Logging (WAL) for concurrency. If the application or machine restarts mid-operation, LifeOps inspects unfulfilled workflows and resumes idempotent tasks without duplicating actions.

The "Wow Moment": Vendor Cancellation Recovery

During the primary demo scenario, a simulated external emergency occurs: SwiftShift Movers cancels the moving booking due to vehicle breakdown.

LifeOps reacts autonomously:

1. Event Reception: Listens to mock system webhooks (EXTERNAL_EVENT_RECEIVED).
2. State Transition: Marks the original movers task as CANCELLED.
3. Autonomous Replanning: Wakes up, triggers the Research Agent to query replacement options (Metro Express Logistics at ₹11,500), and generates a new approval request.
4. Sign-Off & Verification: Once approved, books the replacement and verifies the confirmation code in the provider database.

5. Local-First, No-GCP Compliance Architecture

To ensure strict privacy and developer accessibility, LifeOps operates 100% locally:

• Zero Cloud Infrastructure: 0 dependencies on Cloud Run, Firestore, Pub/Sub, Vertex AI, or Secret Manager.
• Direct Model Inference: Connects directly to the Gemini API (gemini-3.5-flash / gemini-2.5-flash) via GEMINI_API_KEY stored in .env.
• Local Audit Tool: Includes scripts/check_no_gcp.py to audit the repository for prohibited cloud imports or hardcoded keys.

LifeOps Infrastructure Audit
=============================================
Google ADK:       PASS
Gemini API:       PASS (Managed via local .env)
GCP Services:     NONE DETECTED
Secret Leaks:     CLEAN (0 hardcoded keys in source)
SQLite:           PASS
Local Scheduler:  PASS
=============================================
Result: PASSED (NO-GCP & CLEAN SECRETS)

6. Repository & Setup Instructions

The full working source code is available on GitHub:

📌 GitHub Repository: https://github.com/scha54/All-Things-Agentic-Hackathon

Running Locally:

1. Clone & Configure Environment:

   git clone https://github.com/scha54/All-Things-Agentic-Hackathon.git
   cd All-Things-Agentic-Hackathon
   cp .env.example .env
   # Add your GEMINI_API_KEY to .env

1. Initialize Database:

   python scripts/init_db.py

1. Start Mock Digital World (Port 8001):

   python mock_world/server.py

1. Start FastAPI Backend (Port 8000):

   python -m uvicorn backend.app.main:app --reload --port 8000

1. Start React Dashboard:

   cd frontend
   npm install
   npm run dev

1. Run Audits & Tests:

   python scripts/check_no_gcp.py
   python -m unittest discover backend/tests

7. Conclusion

LifeOps proves that personal AI can transcend conversational chat boxes to become true autonomous operations centers. By pairing Google ADK multi-agent orchestration and Gemini document intelligence with deterministic risk guardrails and local SQLite persistence, LifeOps delivers a secure, privacy-preserving solution where users delegate outcomes and software handles the operational heavy lifting.