UserCentrix: An Agentic Memory-augmented AI Framework for Smart Spaces

1. Problem Statement

The rapid evolution of smart spaces requires systems that can deliver highly personalized, real-time, and context-aware user experiences. However, existing approaches face several critical challenges:

• Resource vs. Latency Trade-offs: Deploying Large Language Models (LLMs) in edge-cloud continua often struggles to balance computational cost, inference latency, and decision accuracy, especially under resource-constrained edge conditions.
• Static Decision Making: Traditional agents often lack the ability to dynamically adapt their reasoning depth based on the urgency of user needs (e.g., a meeting starting in 5 minutes vs. one scheduled for next week).
• Scalability and Coordination: As the number of agents increases, managing inter-agent communication, resolving intent conflicts, and maintaining system resilience becomes complex.
• Lack of Memory Integration: Many systems fail to effectively leverage historical user interactions to personalize future responses without retraining, leading to repetitive or contextually irrelevant outputs.

2. Methodology: The UserCentrix Framework

UserCentrix is a hybrid agentic orchestration framework designed to optimize resource management and enhance user experience through urgency-aware and intent-driven decision-making. It operates on a dual-layer architecture: User Side (personalized agents) and Building Side (environment management).

Core Architectural Components

1. User Side (Personal Agent):

   • Memory-Augmented Reasoning: Utilizes a scalable, external memory repository to store past interactions (plans, preferences, timestamps). It employs Case-Based Reasoning (CBR) to retrieve and adapt past solutions for new intents.
   • Self-Evaluation: Agents validate generated outputs against original user intents to ensure alignment and trustworthiness.
   • In-Context Learning: The system evolves its prompt strategies by injecting successful past solutions and evaluator feedback into new prompts, improving performance over time without retraining.

2. Building Side (Smart Environment):

   • Decision-Making Module:
     • Classifier Agent: Categorizes user intents into High-Urgency (time difference < 2 hours) or Low-Urgency (time difference ≥ 2 hours).
     • High-Urgency Agent ($A_{High}$): Prioritizes speed. It generates streamlined reasoning paths, minimizes sub-tasks, and limits LLM calls to ensure rapid execution.
     • Low-Urgency Agent ($A_{Low}$): Prioritizes accuracy. It generates multiple reasoning paths, explores diverse solution strategies, and leverages memory for in-depth analysis.
     • Pareto Optimization: A Pareto Analyzer evaluates candidate solutions based on three fitness functions: Semantic Similarity (intent fulfillment), Precision (output alignment), and LM Call Usage Cost (a non-linear decay function penalizing excessive LLM calls). It selects the dominant solution to balance accuracy and cost.
   • Sub-tasks Execution Module:
     • Deploys low-level agents to execute specific sub-tasks (e.g., booking a room, adjusting temperature).
     • Uses Rendezvous Points (RPs) as shared memory for agents to negotiate and resolve conflicts (e.g., double-booking) via cooperative reasoning.
   • Management and Analysis Module:
     • Manages a message queue with Time-to-Launch (TTL) settings to schedule command dispatch.
     • Includes an Environment Agent that continuously monitors real-time sensor data against user requirements. If deviations occur, it generates corrective commands autonomously.

Technical Implementation

• Models Tested: The framework was evaluated using a diverse set of models including GPT-4o, Gemini 1.5 Flash, Claude 3.5 Sonnet, Mistral, Command-r7b, and IBM Granite 3.1-MoE.
• Deployment: Experiments were conducted in a hybrid Edge-Cloud setting (Edge: Intel i5 with 16GB RAM; Cloud: Google Colab with Xeon CPU).
• Evaluation Metrics: Elapsed time, CPU/Memory utilization, Semantic Similarity, Precision, Recall, and Factual Correctness (using Human-in-the-Loop and LLM-as-a-Judge).

3. Key Contributions

• Urgency-Aware Auto-Scaling: A novel mechanism that dynamically adjusts the number of agents, reasoning depth, and LLM calls based on the urgency of the user intent, ensuring timely responses for critical tasks while allowing deep analysis for non-critical ones.
• Hybrid Agentic Orchestration: Integration of personalized user agents with building management agents, coordinated through a memory-augmented, Pareto-optimized decision loop.
• Cooperative Conflict Resolution: Implementation of Rendezvous Points (RPs) enabling low-level agents to negotiate and resolve execution conflicts autonomously.
• Continuous Learning Loop: A feedback mechanism where an Evaluator Agent (powered by o1) selects optimal solutions and injects them back into the memory, enabling the system to refine its prompt strategies and decision logic via in-context learning.
• Comprehensive Benchmarking: A rigorous evaluation of multiple LLMs and SLMs across edge and cloud environments, providing empirical data on the trade-offs between model size, latency, and accuracy in smart space applications.

4. Experimental Results

The framework was tested using the University of Oulu Smart Campus Dataset (involving meeting rooms with CO2, temperature, and light sensors).

• Model Performance:

  • GPT-4o and Gemini 1.5 Flash emerged as the most efficient models, offering the best trade-off between low latency, minimal CPU/memory usage, and high accuracy.
  • GPT-4o achieved the lowest latency (e.g., ~1.38s on edge for high-urgency tasks) and maintained perfect accuracy (1.0) in environment monitoring.
  • Large models like Claude 3.5 Sonnet and Mistral showed significantly higher latency (hundreds of seconds) and resource consumption, making them less suitable for real-time edge deployment.
  • Small models like Command-r7b and Granite 3.1-MoE showed mixed results; while faster than some large models, they often suffered from lower accuracy or high memory spikes on edge devices.

• Urgency Handling:

  • High-Urgency scenarios successfully reduced LM call counts and hierarchy depth, resulting in faster execution times (e.g., Gemini 1.5 Flash reduced from ~10s to ~4s).
  • Low-Urgency scenarios allowed for deeper reasoning, generating multiple solutions and achieving higher precision scores through Pareto optimization.

• Learning Impact:

  • After in-context learning, the system demonstrated improved alignment between Pareto-optimal selections and evaluator choices, with similarity scores increasing by approximately 6.1%.
  • The system successfully retrieved relevant past preferences to personalize new intents, even when memory was initially empty.

5. Significance and Impact

• Autonomous Smart Spaces: UserCentrix demonstrates that AI-driven smart spaces can operate autonomously, handling complex, multi-step tasks (booking, environmental control) without human intervention while maintaining high Quality of Experience (QoE).
• Resource Efficiency: By dynamically scaling resources based on intent urgency, the framework prevents resource wastage on simple tasks and ensures robustness for critical ones, a crucial advancement for edge computing.
• Scalable Architecture: The use of cooperative reasoning networks and Pareto optimization provides a blueprint for scaling multi-agent systems in distributed environments without incurring prohibitive communication overhead.
• Practical Deployment: The study provides actionable insights for developers on selecting appropriate models (e.g., GPT-4o or Gemini 1.5 Flash) for specific smart space scenarios, balancing the need for speed, accuracy, and computational cost.

In conclusion, UserCentrix represents a significant step forward in Agentic AI, moving beyond static chatbots to dynamic, memory-augmented systems capable of real-time, intent-driven orchestration in complex, resource-constrained environments.