DEV Community

Sandeep Chakravartty
Sandeep Chakravartty

Posted on

LifeOps: Delegating Outcomes, Not Checklists

#ai #productivity #antigravity #hackathon

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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:

Action Name Risk Level Action Taken
read_document, extract_facts LOW Auto-Executed
query_provider_api, check_slots LOW Auto-Executed
draft_email, send_notification MEDIUM Auto-Executed
request_internet_transfer MEDIUM Auto-Executed
book_moving_company (Cost: ₹12,500) HIGH PAUSES WORKFLOW — Requires Approval
book_broadband_installation HIGH PAUSES WORKFLOW — Requires Approval
financial_transaction, cancel_contract CRITICAL PAUSES WORKFLOW — Requires Approval

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)
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode
  1. Initialize Database: 
   python scripts/init_db.py
Enter fullscreen mode Exit fullscreen mode
  1. Start Mock Digital World (Port 8001): 
   python mock_world/server.py
Enter fullscreen mode Exit fullscreen mode
  1. Start FastAPI Backend (Port 8000): 
   python -m uvicorn backend.app.main:app --reload --port 8000
Enter fullscreen mode Exit fullscreen mode
  1. Start React Dashboard: 
   cd frontend
   npm install
   npm run dev
Enter fullscreen mode Exit fullscreen mode
  1. Run Audits & Tests: 
   python scripts/check_no_gcp.py
   python -m unittest discover backend/tests
Enter fullscreen mode Exit fullscreen mode

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.

Top comments (0)