LIA

Intelligent multi-agent conversational assistant with LangGraph orchestration, Human-in-the-Loop, enterprise-grade observability, and full i18n support (6 languages)

If you find my project and work valuable, I would be grateful for a star on GitHub. Thank you !

Features • Admin & Monitoring • Quick Start • Architecture • Documentation • Contributing

Version 1.16.9 — Chat UX polish: LaTeX math rendering (`$E=mc^2$`), syntax highlighting on code blocks (25 languages, Prism one-dark/one-light, lazy-loaded), copy buttons on messages and code blocks, relative dates ("Yesterday 14:30" / "Monday 14:30"), conversation history search (PostgreSQL ILIKE + client-side instant filter), Tooltip primitive (Radix) migrated across chat. A11y: TypingIndicator with role/aria-live, textarea mobile attrs (autoCapitalize/autoCorrect/enterKeyHint). Bug fixes: proactive feedback persisted in `message_metadata` JSONB (cross-session/cross-device), Weather & Philips Hue tools now localized to user language (Option C thread-safe via `ConnectorTool._fetch_language()` + `_language_from_result()`), skill-generator delivers all files — April 2026

• Why LIA?
• Try LIA Online
• Screenshots
• Features
• Administration & Monitoring
• Quick Start
• Architecture
• Technologies
• Documentation
• Tests
• CI/CD
• Performance
• Security
• Contributing
• Support
• License
• Acknowledgments

LIA solves the fundamental problems of today's AI assistants:

📅 "Find my meetings for tomorrow and send a reminder to all participants"
📧 "Summarize my unread emails from this week that have attachments"
👥 "Update the companies of my contacts who work at startups"
🔔 "Remind me tomorrow at 9am to call Marie for her birthday"

LIA is available as a hosted service at https://lia.jeyswork.com/ — no installation required.

Closed beta: Access is currently limited to a restricted number of users, at the administrator's discretion. To request an invitation, contact liamyassistant@gmail.com.

Dashboard — Homepage with quick access, usage statistics, and personalized greeting

Chat — Multi-agent conversation with real-time debug panel (right sidebar)

• 19+ Specialized Agents: Contacts, Emails, Calendar, Drive, Tasks, Reminders, Places, Routes, Weather, Wikipedia, Perplexity, Brave, Web Search, Web Fetch, Browser Control (with progressive screenshot streaming), Smart Home (Philips Hue), Context, Query + dynamic MCP agents
• ReAct Execution Mode (ADR-070): Alternative to the pipeline — the LLM iteratively reasons about tool outputs and decides next steps autonomously. User-toggleable preference, 4-node LangGraph architecture with native HITL support, timeout enforcement, cross-domain initiative via prompt engineering. Supports all tools including MCP and Skills
• MCP (Model Context Protocol): Per-user external tool servers with OAuth 2.1, SSRF protection, structured items parsing, MCP Apps (interactive iframe widgets), Iterative Mode (ReAct) for complex servers — a dedicated agent reads docs then calls tools correctly
• Agent Initiative Phase: Post-execution cross-domain enrichment — the assistant proactively verifies related information (e.g., weather shows rain → checks calendar for outdoor events). Prompt-driven, read-only, fully configurable
• Skills (agentskills.io) with Rich Outputs: Open standard for expert instructions (SKILL.md), model-driven activation, progressive disclosure (L1/L2/L3), sandboxed scripts, marketplace import, auto-translated multi-language descriptions, ZIP download, admin management. Rich Skill Outputs (v1.16.8): skills can return interactive HTML frames (iframe srcDoc or external URL) and/or images in addition to text, via a simple JSON contract (SkillScriptOutput). Automatic theme & locale sync (theme switch propagates live to frames via postMessage), iframe auto-resize, CSP-sandboxed client-side interactivity (addEventListener, crypto.getRandomValues), bundled segno for QR codes. Seven built-in rich skills: interactive-map, weather-dashboard, calendar-month, qr-code, pomodoro-timer, unit-converter, dice-roller. Planner skill guard: multi-domain deterministic skills are protected from false-positive early clarification requests via domain overlap detection (_has_potential_skill_match). Built-in Skill Generator: create custom skills in natural language — the assistant guides you through need analysis, archetype selection, and produces a ready-to-import SKILL.md with automatic validation
• AI Image Generation & Editing: Generate images from text prompts (gpt-image-1), edit existing images with natural language instructions. Multi-provider factory architecture, per-user quality/size preferences, cost tracking with DB-cached pricing, attachment-based storage with cascade cleanup
• File Attachments (Images, PDF): Upload with client-side compression, configurable LLM vision analysis, PDF text extraction, strict per-user isolation
• Semantic Routing: Binary classification with confidence scoring (high >0.85, medium >0.65)
• Multi-Step Planning: ExecutionPlan DSL with dependencies and conditions
• Parallel Execution: asyncio.gather for independent domains
• Intelligent Context Compaction: LLM-based conversation history summarization when token count exceeds dynamic threshold (ratio of response model context window). Preserves identifiers (UUIDs, URLs, emails). /resume command for manual trigger. 4 HITL safety conditions prevent compaction during active approval flows

• 5-Layer Psychological State: Big Five personality traits (permanent) → PAD mood space with 14 moods (hours) → 22 discrete emotions with cross-suppression (minutes) → 4-stage relationship progression (weeks) → curiosity/engagement drives (per-session)
• Show, Don't Tell: Mood and emotions subtly influence word choice, sentence rhythm, energy level, and relational tone — the assistant never declares "I'm feeling happy"
• Emotional Avatar: Mood-responsive emoji with colored ring on each message. Historical avatars persisted per-message for reload consistency
• Evolution Awareness: The assistant knows how its mood shifted since the last message, providing narrative continuity
• 4-Chart Dashboard: Interactive recharts visualization of mood (PAD), emotions, relationship, and drives over time (24h to 90 days)
• Education Guide: 7-section interactive documentation explaining every layer, with descriptive tables for 14 moods and 22 emotions
• Customizable Temperament: Expressiveness (stoic → highly expressive) and stability (volatile → very stable) sliders. Soft reset (mood only) and full reset (everything) with explicit scope descriptions
• Global Injection: Behavioral directives injected via template variables into all user-facing text generation (response, notifications, reminders, voice) within semantic XML blocks (<InnerState purpose="tone-calibration">)
• Safety Guardrail: Explicit instruction prevents the LLM from projecting its own emotional state onto the user
• Self-Report: Zero-cost emotion tracking via hidden <psyche_eval/> tag — no additional LLM call

Voice Input (STT)

• Push-to-Talk: Hold microphone button to speak, release to transcribe. Optimized for mobile (anti-long-press CSS, touch gesture handling)
• Wake Word: Say "OK Guy" to activate hands-free recording. Sherpa-onnx WASM (Whisper Tiny.en) runs entirely in-browser — no audio sent externally for wake word detection
• Per-User Language: STT transcription uses the user's preferred language setting (Whisper Small, 99+ languages, fully offline)
• Latency Optimized: Mic stream reuse, WebSocket pre-warming, parallel setup, cached AudioWorklet (~50-100ms wake-to-record)

Voice Output (TTS)

• Factory Pattern: Interchangeable implementations
• Admin Control: Mode controlled via System Settings
• Graceful Degradation: Automatic HD to Standard fallback

# DSL Syntax
ExecutionStep(
    tool_name="send_email",
    for_each="$steps.get_contacts.contacts",
    for_each_max=10
)

• HITL Thresholds: Mutations >= 1 trigger mandatory approval
• Bulk Operations: Send emails, update contacts, mass deletions

• Gmail: Search, read, send, reply, trash
• Contacts: Fuzzy search, list, details (14+ schemas)
• Calendar: Search, create, update events
• Drive: Search, file/folder listing
• Tasks: Full CRUD with completion

• Apple Mail: Search, read, send, reply, forward, trash (IMAP/SMTP)
• Apple Calendar: Search, create, update, delete events (CalDAV)
• Apple Contacts: Search, list, create, update, delete (CardDAV)

• Outlook: Search, read, send, reply, forward, trash (Graph API)
• Calendar: Search, create, update, delete events (calendarView)
• Contacts: Search, list, create, update, delete
• To Do: Full CRUD with completion (task lists + tasks)
• Multi-tenant: Personal accounts (outlook.com) and business accounts (Azure AD) via tenant=common

• Only one provider per functional category (email, calendar, contacts, tasks)
• 3 supported providers: Google, Apple, Microsoft
• Activating a new provider automatically deactivates the active competitor

• Voice-controlled lighting: Turn lights on/off, adjust brightness and colors via natural language
• Room & scene management: Control entire rooms or activate predefined scenes ("dim the living room", "activate movie mode")
• Local or cloud connection: Connect via local bridge IP or Philips Hue cloud API
• Feature flag: PHILIPS_HUE_ENABLED=true to enable

• Prometheus: 500+ custom metrics (agents, LLM, infrastructure)
• Grafana: 20 production-ready dashboards
• Langfuse: LLM-specific tracing with prompt versions
• Loki: Structured JSON logs with PII filtering
• Tempo: Distributed cross-service tracing

• Google Maps Platform: Places, Routes, Geocoding, Static Maps
• Dynamic Pricing: Admin UI for pricing CRUD
• ContextVar Pattern: Implicit tracking without explicit parameter passing
• Admin CSV Exports: Token usage, Google API usage, Consumption summary (all users or filtered by user)
• User CSV Exports (v1.9.1): Personal consumption export in Settings > Features — users export their own data only (user_id forced server-side, IDOR-safe)

• OAuth 2.1: PKCE (S256), single-use state token
• BFF Pattern: HTTP-only cookies, Redis session with 24h TTL
• Encryption: Fernet (credentials), bcrypt (passwords)
• GDPR: Automatic PII filtering, pseudonymization, personal data export (Art. 20 data portability)
• Per-User Usage Limits: Token, message, and cost quotas (period/global) with 5-layer defense-in-depth enforcement, admin kill switch, real-time dashboard with WebSocket gauges. Feature flag: USAGE_LIMITS_ENABLED=true

• Per-user external servers: Each user connects their own MCP servers (third-party tools)
• Flexible authentication: None, API Key, Bearer Token, OAuth 2.1 (DCR + PKCE S256)
• Enhanced security: HTTPS-only, SSRF prevention (DNS resolution + IP blocklist), encrypted credentials (Fernet)
• Structured Items Parsing: Automatic JSON array detection into individual items with McpResultCard HTML
• Auto-generated descriptions: LLM analysis of discovered tools to generate domain descriptions optimized for intelligent routing
• Per-server rate limiting: Redis sliding window per server/tool
• Feature flag: MCP_USER_ENABLED=true to enable per-user

• Bidirectional Telegram: Full chat with LIA via Telegram (text, voice, HITL)
• OTP Linking: Secure account-to-Telegram linking via 6-digit OTP code (single-use, 5min TTL, brute-force protection)
• HITL Inline Keyboards: Approval/rejection buttons localized in 6 languages directly in Telegram
• Voice Transcription: Telegram voice messages to STT (Sherpa Whisper) to text processing
• Proactive Notifications: Reminders and interest alerts also sent via Telegram
• Extensible Architecture: BaseChannelSender/BaseChannelWebhookHandler abstraction for future channels (Discord, WhatsApp)
• Observability: 12 dedicated Prometheus RED metrics (latency, errors, volumes)
• Feature flag: CHANNELS_ENABLED=true to enable

• LLM-driven proactivity: LIA takes the initiative to inform you when relevant (weather, calendar, interests)
• Multi-source aggregation: Calendar, Weather (with change detection), Tasks, Interests, Memories, Activity — parallel fetch
• 2-phase LLM decision: Phase 1 (structured output, cost-effective model) decides whether to notify, Phase 2 rewrites with user personality and language
• Intelligent anti-redundancy: Recent history + cross-type dedup (heartbeat vs. interests) in the decision prompt
• User control: Push notifications (FCM/Telegram) independently toggleable, configurable daily max (1-8), dedicated time windows (independent from interests)
• Weather change detection: Rain start/end, temperature drops, wind alerts — truly actionable notifications
• Feature flag: HEARTBEAT_ENABLED=true to enable

• Recurring actions: Schedule repetitive actions executed automatically (send emails, checks, reminders)
• Timezone-aware: Correct timezone handling per user
• Retry logic: Automatic retries on failure with back-off
• Auto-disable: Automatic deactivation after N consecutive failures
• Multi-channel integration: Result notifications via FCM, SSE, and Telegram
• Feature flag: SCHEDULED_ACTIONS_ENABLED=true to enable

• Persistent specialized agents: Create sub-agents with custom instructions, skills, and LLM configuration
• Read-only V1: Sub-agents perform research, analysis, and synthesis — no write operations
• Template-based creation: Pre-defined templates (Research Assistant, Writing Assistant, Data Analyst)
• Invisible to user: The principal assistant orchestrates sub-agents and presents results naturally
• Token guard-rails: Per-execution budget, daily budget, auto-disable after consecutive failures
• Feature flag: SUB_AGENTS_ENABLED=true to enable (default: false)

• Personal knowledge bases: Create spaces, upload documents in 15+ formats (PDF, DOCX, PPTX, XLSX, CSV, RTF, HTML, EPUB, and more), automatic chunking and embedding
• Google Drive folder sync: Link Google Drive folders to spaces for automatic file vectorization with incremental change detection (new, modified, deleted). Feature flag: RAG_SPACES_DRIVE_SYNC_ENABLED
• Hybrid search: Semantic similarity (pgvector cosine) + BM25 keyword matching with configurable alpha fusion
• Response enrichment: RAG context automatically injected into assistant responses when active spaces exist
• Full cost transparency: Embedding costs tracked per document and per query, visible in chat bubbles and dashboard
• System knowledge spaces: Built-in FAQ knowledge base (119+ Q/A across 17 sections) indexed from Markdown files (docs/knowledge/). is_app_help_query detection by QueryAnalyzer, RoutingDecider Rule 0 override, App Identity Prompt injection with lazy loading (zero overhead on normal queries). Auto-indexed at startup with SHA-256 hash-based staleness. Admin UI for reindex and staleness monitoring. ADR-058
• Admin reindexation: Full reindex when embedding model changes, with Redis mutual exclusion and automatic dimension ALTER. System spaces have independent reindex via admin API
• Observability: 17 Prometheus metrics (14 user + 3 system), dedicated Grafana dashboard
• Feature flags: RAG_SPACES_ENABLED=true (user spaces), RAG_SPACES_SYSTEM_ENABLED=true (system FAQ spaces)

• Introspective notebooks: The assistant maintains thematic journals (self-reflection, user observations, ideas & analyses, learnings) written in first person, colored by its active personality
• Dual trigger: Post-conversation extraction (fire-and-forget) + periodic consolidation (APScheduler). The assistant decides freely what to write
• Semantic context injection: Journal entries injected into both response AND planner prompts via Gemini embedding-001 similarity search with configurable minimum score prefiltering (JOURNAL_CONTEXT_MIN_SCORE). Results include scores — the LLM decides relevance autonomously
• Prompt-driven lifecycle: The assistant manages its own journals — no hardcoded auto-archival. Size constraints guide cleanup via prompt engineering
• Heartbeat integration: Journal entries enrich proactive notifications via dynamic second-pass query built from aggregated context (calendar, weather, emails). Toggleable source badge in heartbeat settings
• Full user control: Enable/disable (data preserved), consolidation toggle, conversation history analysis (with cost warning), 4 configurable numeric settings, full CRUD in Settings
• Anti-hallucination guards: Three-layer defense against LLM UUID hallucination — prompt guidance with ID reference tables, field_validator on entry IDs, and known-ID filtering in both extraction and consolidation services
• Debug panel: Dedicated "Personal Journals" section showing injection metrics (per-entry scores with visual bars, budget indicators) AND background extraction results (actions parsed/applied, CREATE/UPDATE/DELETE badges, themes, moods). Extraction data arrives via supplementary debug_metrics_update SSE event after background tasks complete
• Cost transparency: Real token costs tracked via TrackingContext, visible in Settings and dashboard
• Feature flags: JOURNALS_ENABLED=false (system), user-level toggle in Settings > Features. ADR-057

• Two token-authenticated endpoints (POST /api/v1/ingest/health/steps and /api/v1/ingest/health/heart_rate): an iPhone Shortcut automation pushes daily batches of samples. Each sample carries its own ISO 8601 date_start / date_end — UTC-normalized server-side and second-truncated to keep uniqueness stable.
• Polymorphic single-table storage (health_samples): one row per sample with a kind discriminator (heart_rate | steps). Extending to spo2 / sleep / calories reduces to a new kind value — no new table, no new endpoint.
• Idempotent UPSERT (ON CONFLICT (user_id, kind, date_start, date_end) DO UPDATE) using PostgreSQL's RETURNING (xmax = 0) trick to split insert vs update counts in a single round-trip. Re-sending the same batch is free — last value wins.
• Flexible body parser: accepts JSON array, NDJSON, {"data": [...]} envelope, and the iOS Shortcuts "Dictionnaire" wrapping ({"<ndjson_blob>": {}}) — no contract pressure on the user's Raccourci authoring.
• Per-user hashed tokens: SHA-256 digest stored, raw value (hm_xxx) returned once at generation, display prefix shown in Settings, individually revocable. Multiple tokens may coexist for rotation.
• Mixed per-sample validation: out-of-range / malformed / missing-field / invalid-date samples are individually rejected with their 0-based index + reason, while valid siblings in the same batch persist.
• Bucketed aggregation (hour / day / week / month / year): heart rate averaged (plus min / max), steps SUM-ed per bucket; gaps kept (has_data=False) so the UI displays honest curves.
• Settings visualization: four-section panel (ingestion API + tokens, recharts line/bar charts with period average overlays, statistics, deletion by kind or full wipe).
• GDPR-aware: deletion by kind (DELETE ?kind=...), full erasure (DELETE /all), ON DELETE CASCADE on the user FK.
• Observability: bounded-cardinality Prometheus metrics (health_samples_upserted_total{kind, operation}, validation rejections, rate-limit hits, auth failures, token lifecycle, deletions, latency histogram) + Grafana dashboard 21.
• Guards: 60 req/h/token sliding-window rate limit (configurable), 1000 samples/batch cap (413 beyond).
• Feature flag: HEALTH_METRICS_ENABLED=false (system). ADR-076 · Guide iPhone · Technical doc

• Sandboxed iframes: MCP applications rendered in secure iframes (CSP + COEP credentialless)
• JSON-RPC Bridge: Bidirectional communication between iframe app and chat via PostMessage JSON-RPC 2.0
• Excalidraw Iterative Builder: Intent-based diagram generation via dedicated LLM calls (shapes + arrows) with cheat sheet injection for format accuracy
• read_me convention: MCP servers exposing a read_me tool have their content auto-injected into the planner prompt
• Auto-generated descriptions: LLM analysis of discovered tools for domain description optimized for routing
• App-only tools: Tools with visibility: ["app"] filtered from the LLM catalogue (iframe only)

LIA is fully translated in 6 languages: English, French, German, Spanish, Italian, and Chinese.

• Complete UI coverage: All interfaces, dialogs, notifications, error messages, FAQ, and landing page
• HITL localized: Human-in-the-Loop approval prompts adapted per language
• Proactive notifications: Heartbeat and reminders delivered in the user's language
• Telegram: Inline keyboards and messages localized
• Skills: Auto-translated descriptions in all 6 languages
• react-i18next: Namespace-based translations with locales/{lang}/translation.json

• Presentation page: Responsive landing page with animated components (Hero, Features, Architecture, Security, Stats, Use Cases, How It Works, CTA)
• SEO & OpenGraph: Dynamically generated OG image for social media previews
• Authenticated redirect: Automatic redirect to dashboard if already logged in

LIA includes a full-featured administration interface — giving operators complete control and real-time visibility over the system without touching configuration files or the database.

A web-based administration panel covering every operational aspect:

A 24-section debug panel embedded in the chat interface, organized into 6 logical groups with always-visible sections (empty sections show "N/A" instead of disappearing):

The debug panel is designed for developers and operators to diagnose issues, optimize prompts, and understand the agent's decision-making process in real time — without needing external tools or log access.

All commands are defined in Taskfile.yml. Quick start: task setup then task dev.

# 1. Clone the repository
git clone https://github.com/jgouviergmail/LIA-Assistant.git
cd LIA-Assistant

# 2. Configure environment
cp .env.example .env  # Edit with your API keys

# 3. Full setup (backend + frontend + git hooks)
task setup

# 4. Start all services (API + Web + PostgreSQL + Redis + observability)
task dev

# 1. Start the infrastructure
docker compose up -d postgres redis prometheus grafana

# 2. Backend setup
cd apps/api
python -m venv .venv && source .venv/bin/activate  # Windows: .venv\Scripts\activate
pip install -r requirements.txt
cp ../../.env.example .env  # Configure your API keys

# 3. Database migrations
alembic upgrade head

# 4. Frontend setup
cd ../web
pnpm install

# 5. Start the services
# Terminal 1 - Backend:
cd apps/api && uvicorn src.main:app --reload --port 8000

# Terminal 2 - Frontend:
cd apps/web && pnpm dev

# Database
DATABASE_URL=postgresql+asyncpg://user:pass@localhost:5432/lia
REDIS_URL=redis://localhost:6379/0

# Security (REQUIRED - change in production)
SECRET_KEY=change-me-in-production-use-openssl-rand-base64-32
FERNET_KEY=your-fernet-key-here

# LLM Provider API keys are configured via Admin UI after first login
# (Settings > Administration > LLM Configuration)
# At least one provider (typically OpenAI) is required.

# Google OAuth (optional)
GOOGLE_CLIENT_ID=...
GOOGLE_CLIENT_SECRET=...

# Feature Flags (optional, disabled by default)
MCP_ENABLED=false              # Admin MCP servers
MCP_USER_ENABLED=false         # Per-user MCP (requires MCP_ENABLED)
CHANNELS_ENABLED=false         # Multi-channel messaging (Telegram)
HEARTBEAT_ENABLED=false        # Autonomous proactive notifications
SCHEDULED_ACTIONS_ENABLED=false # Recurring scheduled actions
SUB_AGENTS_ENABLED=false       # Persistent specialized sub-agents
SKILLS_ENABLED=false           # Skills system (agentskills.io standard)
RAG_SPACES_ENABLED=true        # RAG Knowledge Spaces (document upload & retrieval)
FCM_NOTIFICATIONS_ENABLED=false # Firebase push notifications

Production targets include Raspberry Pi (ARM64) via multi-arch Docker builds (linux/amd64,linux/arm64).

┌─────────────────────────────────────────────────────────────────────────┐
│                        FRONTEND (Next.js 16 + React 19)                  │
│    Chat UI • Settings • i18n (6 languages) • SSE Streaming • Voice Mode  │
└─────────────────────────────┬───────────────────────────────────────────┘
                              │ HTTP-only cookies (session_id, 24h TTL)
┌─────────────────────────────┴───────────────────────────────────────────┐
│                     BACKEND (FastAPI + LangGraph 1.x)                    │
│                                                                          │
│  ┌────────────────────────────────────────────────────────────────────┐ │
│  │                 LangGraph Multi-Agent Orchestration                 │ │
│  │                                                                      │ │
│  │   Router → QueryAnalyzer → Planner → ApprovalGate → Orchestrator   │ │
│  │      ↓                                        ↓                     │ │
│  │   ┌─────────────────────────────────────────────────────────────┐  │ │
│  │   │  Contacts │ Emails │ Calendar │ Drive │ Tasks │ Reminders  │  │ │
│  │   │  Places │ Routes │ Weather │ Wikipedia │ Perplexity      │  │ │
│  │   │  Brave │ Web Search │ Web Fetch │ Browser │ Context │ Query│  │ │
│  │   └─────────────────────────────────────────────────────────────┘  │ │
│  │                              ↓                                      │ │
│  │               MCP Tools (per-user external servers)                │ │
│  │                              ↓                                      │ │
│  │                       Response Node (synthesis)                     │ │
│  └────────────────────────────────────────────────────────────────────┘ │
│                                                                          │
│  ┌─────────────────────────────────────────────────────────────────────┐│
│  │  Domain Services: Auth, Users, Connectors, RAG, Voice, Skills...    ││
│  └─────────────────────────────────────────────────────────────────────┘│
│                                                                          │
│  ┌─────────────────────────────────────────────────────────────────────┐│
│  │  Infrastructure: Redis (cache) • PostgreSQL (checkpoints) •         ││
│  │  MCP Client Pool • Prometheus (metrics) • Langfuse (traces)       ││
│  └─────────────────────────────────────────────────────────────────────┘│
└──────────────────────────────────────────────────────────────────────────┘

LIA offers two execution strategies, switchable per user via a toggle in the chat header:

Pipeline mode (default) — A feat of engineering that delivers the same power as ReAct with 4–8× fewer tokens:

1. A smart Planner decomposes the request into an optimized execution plan (DSL)
2. A Semantic Validator checks plan coherence (cardinality, scope, dependencies)
3. An Approval Gate handles HITL for mutations
4. A Task Orchestrator executes tools in parallel waves via asyncio.gather()
5. Bayesian learning optimizes planning patterns over time

ReAct mode (⚡) — The LLM reasons iteratively, calling tools one by one and adapting to each result. More autonomous but higher token cost. Ideal for exploratory, research, or ambiguous queries.