AIlice

AIlice organizes agents in a hierarchical tree structure where the root agent (APromptMain) decomposes complex tasks into subtasks and delegates them to specialized child agents. Each agent can call other agents and receive bidirectional feedback, enabling fault tolerance through error correction loops where agents can escalate unclear requirements back to callers. This pattern replaces traditional sequential function calling with a tree-based coordination model that naturally handles task dependencies and agent collaboration.

AIlice implements a flexible parsing layer (via AInterpreter and AProcessor) that can extract function calls and structured data from LLM outputs using multiple strategies beyond strict JSON parsing. The system uses regex-based pattern matching and custom parsing rules to handle varied LLM response formats, allowing agents to interpret incomplete, malformed, or creative function call syntax. This enables compatibility with multiple LLM providers and models that produce inconsistent output formatting.

AIlice includes a prompt template system that defines specialized agent roles (researcher, coder, simple assistant, coder proxy) through pre-written prompts. Each template encodes domain-specific instructions, reasoning patterns, and tool usage guidelines. Templates are composable and can be customized for different tasks, enabling rapid agent creation without rewriting core logic. The system uses regex-based prompt parsing (ARegex) to extract structured information from template outputs.

AIlice provides infrastructure for fine-tuning LLMs on custom datasets to improve agent performance for specific domains or tasks. The system includes utilities for preparing training data, managing fine-tuning jobs, and evaluating fine-tuned models. This enables organizations to create specialized models optimized for their use cases rather than relying solely on general-purpose foundation models.

AIlice includes deployment utilities and containerization support (Docker) for packaging and deploying agent systems in production environments. The system provides configuration management for different deployment scenarios (local, cloud, on-premise) and includes documentation for scaling and monitoring deployed agents. This enables organizations to move from development to production with minimal additional work.

AIlice provides a module registry and loading system (AMCPWrapper and module APIs) that allows agents to dynamically discover, load, and invoke external capabilities at runtime. Agents can self-construct new modules by generating code that implements required interfaces, enabling the system to extend its capabilities without pre-registration. Modules communicate with the core system through a standardized RPC interface, allowing both built-in modules (code execution, web search, file I/O) and user-defined extensions to integrate seamlessly.

AIlice implements an abstraction layer for LLM integration that supports multiple providers (OpenAI, Anthropic, Ollama, etc.) through a unified interface. The system includes LLM pooling mechanisms to distribute requests across multiple model instances or providers, enabling load balancing and fallback strategies. Prompt formatting is abstracted to handle provider-specific requirements (token limits, context window sizes, special tokens), allowing agents to work transparently across different LLM backends.

AIlice includes a specialized research agent (prompt_researcher) that can autonomously investigate topics by formulating search queries, retrieving web results, analyzing documents, and synthesizing findings. The agent integrates with web search modules to fetch current information and can parse and summarize articles and papers. This enables the system to perform in-depth subject investigation and provide up-to-date information without relying on static training data.

AIlice includes a specialized coder agent (prompt_coder) that can generate, review, and execute code in a sandboxed environment. The agent uses the code execution module to run generated scripts safely, capturing output and errors for feedback. The system supports multiple programming languages and can iteratively refine code based on execution results. A proxy coder agent (prompt_coderproxy) can also coordinate with external code execution services.

AIlice supports multimodal inputs including voice transcription and image analysis through integrated modules. The system can accept audio input, transcribe it to text, and process it through the agent pipeline. Image inputs can be analyzed for content, OCR, or used as context for agent reasoning. This enables natural voice-based interaction and visual understanding capabilities beyond text-only interfaces.

AIlice provides both web-based and command-line interfaces for interacting with the agent system. The web interface enables browser-based conversations with persistent session management, while the CLI provides terminal-based access for developers. Both interfaces maintain conversation history and session state, allowing users to resume conversations and track agent actions. The interfaces abstract away the underlying agent complexity, presenting a simple chat-like interaction model.

AIlice implements an RPC communication system that enables distributed execution of agent components across multiple processes or machines. Agents, modules, and services communicate through standardized RPC interfaces, allowing horizontal scaling and separation of concerns. The RPC layer handles serialization, routing, and error handling, enabling transparent remote execution of agent operations.

AIlice includes a storage system that persists conversation history, session state, and agent execution logs. The system supports multiple storage backends (file system, database) and provides APIs for querying and retrieving historical data. This enables conversation resumption, audit trails, and analysis of agent behavior over time.