jumz

Personal companion which dynamically create and manage Personal tasks, and helps us compleate each task

Comment

Inspiration

The inspiration for the Personal Task Companion (PTC) system centers on the need for an AI-powered system to manage tasks and habits across professional, health, and lifestyle domains. The system was conceived to address the difficulty users face in staying on track with goals despite disruptions, requiring the capability to dynamically rearrange schedules when tasks or habits are missed. A key driver was to enable specialized agents to automatically execute tasks using Jumz (Gems) connections that agents establish autonomously, thereby handling routine activities without manual configuration. Furthermore, the system aims to provide a reliable, scalable, and secure task management capability by running entirely on AWS Strands infrastructure.

What it does

The Personal Task Companion (PTC) is the complete AI system designed for personal task and habit management using the AWS Strands SDK. Key functionalities include: • Task Management and Creation The system automatically creates and manages daily tasks across three domains: WORK, HEALTHCARE, and LIFESTYLE. It can generate structured task entries and maintain separate tracking databases for each category. • Dynamic Rearrangement When a task is missed, the PTC automatically reschedules it to the next available time slot, prioritizing tasks based on user-defined importance. • Hierarchical Agent Coordination An Orchestrator Agent serves as the primary interface for users, determining which specialized agents (like Work Agent, Healthcare Agent, Schedule Agent) to engage and providing consolidated status reports. • Jumz (Gems) This is the autonomous connection management system used by agents for linking to Model Context Protocols (MCPs) and external tools, or Agent-to-Agent (A2A) communication. Task Agents use Jumz to execute tasks automatically. The system handles the automatic discovery and dynamic establishment of these connections. • Notifications and Motivation The system delivers social media-style notifications for task completions and schedule changes. It provides Positive Reinforcement messages and tracks achievement streaks to keep users motivated.

How we built it

The PTC system leverages a model-driven approach and key AWS technologies for production readiness. Architecture and Core Frameworks: The system features a hierarchical agent architecture where the top-level Orchestrator Agent coordinates specialized agents. The system is fundamentally built using the AWS Strands Agents SDK. This framework is leveraged for agent orchestration, scalable execution, state management, and an event-driven architecture for real-time updates. Agent and Tool Implementation: Specialized agents (like the Schedule Agent or Habit Agent) are created, and new agents can be generated using the Agent_Builder (a meta-agent) which integrates functionality from BleachAgentBuilder. Tools within the system are Python functions defined using the @tool decorator, which simplifies turning functions into agent tools. All tools must include comprehensive docstrings and type hints, focusing on single responsibilities. Deployment: For enterprise deployment, the system uses the Amazon Bedrock Agent Core SDK. The intended workflow involves configuring necessary resources (IAM roles, ECR, identity providers), testing the Agent Core integration locally, and then deploying through an automated process that includes Docker builds and ECR pushes.

Challenges we ran into

While the sources detail the necessary error handling strategies incorporated into the system's design, they implicitly highlight potential challenges faced in agent operations: • Connection Failures The system requires error handling strategies like automatic retry with exponential backoff and fallback to alternative connections. • Task Execution Failures Strategies are needed for graceful degradation to manual mode, alternative agent assignment, and prompting the user for intervention. • Scheduling Conflicts The design addresses this challenge by requiring intelligent conflict resolution and critical question prompts to the user based on preferences. • Agent Creation Failures If the Agent_Builder fails, the system must handle this by falling back to existing agent templates, logging the error, and potentially offering manual configuration options. • Production Deployment Getting agents into production generally presents difficulties related to security, scalability, and interoperability, which is why the Agent Core SDK is used. Accomplishments that we're proud of The development of the Personal Task Companion demonstrates several key achievements: • Autonomous Connection Management (Jumz/Gems): Successfully defining a system where Task Agents can establish connections autonomously with required MCPs and other agents without manual user configuration. • Dynamic and Intelligent Scheduling: Implementing the capability for Dynamic Rearrangement, allowing the system to automatically and intelligently reschedule missed tasks while preserving user constraints and preferences. • Unified User Interface: Establishing the Orchestrator Agent as the single primary interface, translating user requests into actionable instructions and maintaining conversation context across interactions. • Adaptive System: Creating the Agent_Builder system that can generate functional, new specialized agents based on user descriptions when predefined agents are unsuitable, making the system adaptable to unique needs. • Production Readiness: Successfully designing the system to deploy using the AWS Strands SDK and integrate with Agent Core to provide reliable, scalable, and secure infrastructure. What we learned Development of agentic systems, particularly using Strands, highlighted several best practices and insights: • Model-Centric Orchestration Strands Agents encourage a model-driven approach, relying on the Large Language Model's (LLM) reasoning capabilities for orchestration. This means the agent, not hardcoded dependency logic, figures out the order of tool calls based on natural language instructions. This removes the need to write extensive "plug-in code" between tasks, improving productivity. • Tool Design and Definition It is essential to focus on tool design, decomposing complex problems into domain-specific, single-purpose tools. Defining tools is straightforward using the @tool decorator. • Observability is Critical Robust logging, monitoring, and observability must be implemented from the start. Using good logging mechanisms allows tracing the flow of tools being called, which is important for debugging and understanding agent behavior. • Clear Prompts The system prompts for both the agent and the tools must be specific and clear, as the agent relies on these natural language prompts to understand its tasks, its role, and how to wire up the necessary tools. • Productionizing Agents Transitioning from prototypes to production requires external services like Agent Core to handle heavy lifting related to security, scalability, identity management, and persistent memory.

What's next for jumz

The future development plan for the Personal Task Companion, and specifically the Jumz system, includes focusing on user experience enhancements and completing the connectivity marketplace: • Jumz Registry and Marketplace Plans involve creating a personal Jumz library for user-created gems and developing a public Jumz marketplace for sharing them with other users, including implementing rating, reviews, and usage analytics. • Timeline Interface and Real-Time Updates Implementation of the Timeline Interface for task visualization is planned, including adding WebSocket support for live updates of task statuses and orchestrator communication. • Critical Preference Guidance Building the Critical Preference Questions system is required. This system generates questions when agents need decision guidance, collects user responses, and integrates preference learning to refine task management. • Deployment Finalization The final phase involves deploying the core system on AWS Strands infrastructure, configuring secure data storage, and implementing auto-scaling for the orchestrator and gem execution. • New Agent Validation Ensuring the Agent_Builder validates newly created agents through automated testing before deploying them to the active system is a mandatory requirement

Built With

Share this project:

Updates