Agentic Task Manager: An Intelligent Task Management System Based on Tool-Calling Agents

This project presents an AI-driven task management system built using Python, SQLite, and tool-calling agents, supporting natural language interaction, task lifecycle management, and LLM-powered workflows.

Agentic Task Manager is an open-source AI-driven personal task management system built with Python and SQLite. Its core feature is the deep integration of large language models' tool-calling capabilities. Users can interact with the system via natural language to perform full lifecycle management of tasks—including creation, update, and completion tracking—without needing to remember complex command syntax.

The project adopts a clear layered architecture design:

Data Layer: Uses SQLite as persistent storage, which is lightweight and requires no additional configuration, making it suitable for personal local deployment. The data model covers basic task attributes (title, description, deadline, priority, status, etc.) as well as tag and category information.

Business Logic Layer: Encapsulates core task management operations, including CRUD, status transitions, priority adjustments, etc. This layer remains decoupled from specific LLM implementations, facilitating expansion and testing.

Agent Layer: This is the intelligent core of the system. By defining a set of tool functions (e.g., create_task, update_task, list_tasks, complete_task, etc.), LLMs can autonomously decide which tools to call to fulfill the user's intent based on their natural language input.

Interaction Layer: Provides command-line or API interfaces to receive user input and feed back the agent's execution results to the user.

The core innovation of the project lies in the use of the "Tool Calling" mode to interact with LLMs. The specific process is as follows:

1. Tool Definition: The system predefines a set of tool functions, each with a clear name, description, and parameter schema (JSON Schema).

2. Context Injection: When the user inputs a natural language command, the system injects descriptions of all available tools into the conversation context.

3. Intent Recognition: The LLM analyzes the user's input, determines which tools to call, and generates a structured function call request.

4. Local Execution: The system securely executes the called tool functions locally to operate the SQLite database.

5. Result Feedback: Returns the execution result to the LLM, which generates a natural language response to present to the user.

The advantage of this mode is that LLMs do not directly operate the database; instead, they interact via controlled APIs, ensuring both security and the convenience of natural language interaction.

Task states are managed using a state machine model. Typical state transitions include:

• Todo → In Progress: User starts working on the task
• In Progress → Completed: Task is finished
• Any state → Archived: Task no longer needs tracking

State transitions are implemented via dedicated tool functions, and the agent can understand the user's implicit intent and trigger the corresponding state changes.

The system can handle various natural language expressions:

• Ambiguous time expressions: "tomorrow", "next Wednesday", "three days later"
• Priority descriptions: "urgent", "important", "low priority"
• State descriptions: "I finished X", "start working on Y", "pause Z"
• Compound commands: "Create a high-priority task titled 'Prepare meeting materials' with a deadline of tomorrow afternoon"

Supports full task lifecycle management:

• Task creation: Automatically extracts key information from natural language descriptions
• Task update: Modifies attributes like title, description, deadline, priority, etc.
• Task query: Filters by state, priority, tag, time range
• Task completion: Marks as completed and records the completion time
• Delete/archive: Cleans up tasks that no longer need tracking

• Context awareness: The agent can remember conversation history and support multi-turn interactions
• Intent inference: Can infer reasonable intent even if the user's expression is incomplete
• Clarification queries: Proactively asks questions to clarify requirements when input is ambiguous
• Recommendation generation: Proactively provides management suggestions based on task history and current status