lsdefine/GenericAgent
GenericAgent
GenericAgent is an LLM agent framework and autonomous system controller designed to manage local systems, web browsers, and hardware interfaces through action and observation loops. It functions as a tool orchestrator that routes model calls to local executors, enabling the automation of complex tasks on a host machine.
The project is distinguished by its self-evolving AI agent capabilities, which convert successful execution paths into reusable procedural scripts and skill trees to reduce future reasoning overhead. It employs a context optimization engine that utilizes layered memory hierarchies, information tiering, and conversation compression to minimize token consumption and manage long-term interactions.
The framework covers a broad surface of capabilities including autonomous workflow orchestration, multi-agent workspace isolation, and the ability to synthesize new tools at runtime by installing Python packages. It integrates with various LLM providers, chat platforms, and enterprise productivity tools, while providing mechanisms for tiered failure recovery and human-in-the-loop intervention.
The system is managed via a control console that allows for agent service control, parallel session management, and dialogue history manipulation.
Features
- Agentic LLM Frameworks - Provides a comprehensive framework for building autonomous agents that control local systems and web browsers using language models.
- Autonomous Agent Orchestration - Provides a framework for planning, executing, and verifying complex tasks through an autonomous action-observation loop.
- Hybrid Short-and-Long Term Memory - Implements a memory architecture that integrates immediate session checkpoints with persistent long-term storage.
- Context Optimization Engines - Implements a sophisticated memory system using layered hierarchies and compression to minimize token consumption during long-term interactions.
- Hierarchical Memory Organization - Organizes long-term knowledge into hierarchical levels and loads only relevant information into active context.
- Multi-Layer Memory Architectures - Organizes information into meta-rules, global facts, and session archives to optimize context window usage.
- Concurrent Agent Execution - Spawns isolated child agents to execute multiple tasks concurrently while coordinating with a primary agent.
- Agent Task Execution - Implements an iterative loop of action and observation to execute complex user instructions on local systems.
- Self-Evolving Agent Frameworks - Enables agents to grow a skill tree by converting successful task execution paths into reusable procedural scripts.
- Programmatic Agent Spawning - Launches independent child agents with dedicated workspaces to handle sub-tasks while maintaining primary oversight.
- Autonomous Goal Pursuit - Operates in a self-driven mode focused on a high-level objective until a time or turn limit expires.
- Autonomous System Controllers - Functions as a controller that manages files, terminal commands, and hardware interfaces via LLM-driven loops.
- Autonomous Task Execution - Processes a queue of natural language tasks sequentially during user inactivity and generates reports.
- Autonomous Workflow Automation - Converts manual standard operating procedures into executable code and scheduled background autonomous tasks.
- Knowledge Distillation into Skills - Converts successful execution paths into reusable scripts and procedural memory to reduce future reasoning overhead.
- LLM Cost Management - Optimizes LLM operational costs by compressing conversation history and streamlining tool definitions to reduce tokens.
- LLM Provider Integrations - Supports diverse LLM providers through standardized protocols, including official APIs and local deployments.
- Memory Hierarchies - Implements structured memory hierarchies to organize agent memories and minimize context window bloat.
- On-Demand Context Retrieval - Retrieves specific facts or procedural knowledge using index routing only when identified as necessary for the task.
- Step-by-Step Task Plans - Orchestrates structured workflows involving exploration, planning, user confirmation, and independent verification.
- Tool-Calling Schemas - Uses a unified schema to route structured model calls to local tool executors.
- Governed Agent Memory - Establishes organizational rules and update boundaries for the memory system using a meta-memory layer.
- Dynamic Capability Synthesis - Installs Python packages or writes scripts at runtime to create permanent tools from temporary needs.
- Multi-Tier Memory Systems - Organizes conversation data into meta-rules, global facts, and archives across different latency and persistence tiers.
- LLM Tool Orchestration - Routes model calls to local executors via a unified schema, decoupling tool definitions from their actual implementation.
- Local System Automation - Controls the host machine's terminal, filesystem, and web browser to perform autonomous computer operations.
- System Action Execution - Modifies files via pattern matching, executes code with feedback loops, and operates browsers using JavaScript.
- Request Dispatchers - Routes structured model calls to local executors using a unified schema to decouple tool declarations from implementation.
- Browser Control APIs - Automates web research and data retrieval by executing browser actions via a debugging protocol.
- State Preservation Anchors - Preserves critical task state after message eviction by injecting persistent anchor prompts into the dialogue.
- Verified Experience Distillation - Prevents memory pollution by requiring successful task verification before writing experiences into long-term procedural storage.
- Skill Retrieval - Organizes acquired capabilities and tool scripts into a structured mapping for specialized skill retrieval.
- Agent Workspace Environments - Spawns child agents with dedicated isolated workspaces to execute parallel sub-tasks.
- Conversation History Correction - Removes recent conversation turns to correct instructions and restart a task from a previous state.
- Context Compression - Reduces token usage by truncating tool returns, compressing historical rounds, and removing unnecessary messages.
- Conversation Branching Systems - Duplicates current dialogue history into a new session to explore alternative paths without affecting the original.
- Skill Tree Planning - Prioritizes new tasks based on utility and innovation to strategically expand the agent's skill tree.
- Heuristic Budgeting - Tracks conversation length using a character-domain formula to manage token limits independently of specific model tokenizers.
- Heuristic Token Estimators - Manages token limits using a character-domain heuristic formula to remain independent of specific model tokenizers.
- Human-in-the-Loop Intervention Requests - Pauses autonomous execution to seek user decisions when the agent reaches its capability boundaries.
- Failover Mechanisms - Automatically switches to backup AI model providers when primary services encounter errors or timeouts.
- Procedure-to-Code Compilation - Converts textual procedures into executable scripts to achieve faster and deterministic task completion.
- Real-Time Training Interventions - Modifies running sub-agents by injecting stop signals or new instructions via specialized control files.
- Self-Improving Knowledge Bases - Records errors and user preferences in a log that guides future behavior via system prompts.
- Autonomous Execution Guards - Prevents runaway autonomous loops by enforcing iteration limits and progress-saving mechanisms.
- Verification Loops - Ensures only verified successful task experiences are written to long-term procedural memory to prevent pollution.
- Tool Definition Optimization - Limits available tools to a minimal collection of atomic functions to reduce redundant definition tokens.
- Hardware Interaction - Interacts with physical keyboards, mice, and Android devices via ADB for low-level system control.
- KV Cache Eviction - Implements a first-in-first-out message eviction policy to maintain context window compatibility when the token budget is exceeded.
- Background Task Schedulers - Launches tasks automatically by monitoring environment changes or time-based schedules.
- Agent Session Parallelization - Runs multiple independent conversations in a single interface with separate histories and execution threads.
- Recurring Job Scheduling - Manages triggers to execute specific instructions at fixed intervals or calendar dates using JSON configurations.
- Chat Platform Integrations - Connects the agent to third-party messaging services for remote task triggering and notifications.
- Multi-Channel AI Deployments - Connects the agent core to diverse user interfaces including chat platforms, web apps, and desktop software.
- Session Task Tracking - Tracks high-level goals and execution progress within a persistent working memory anchor.
- Progressive Recovery Flows - Prevents memory pollution and failure by attempting local corrections and strategy shifts before human intervention.
- Error Recovery - Recovers from tool errors through a sequence of local correction, strategy shifting, and human escalation.
- Dynamic Tool Synthesis - Synthesizes new system capabilities at runtime by installing Python packages or writing custom scripts.
- Agentic Error Recovery - Resolves execution errors through a sequence of local self-correction and strategy shifts before requesting human intervention.
- Semantic Layout Analysis - Scans web pages and file segments using layout analysis to extract semantic content while minimizing token usage.
- AI Agents - Self-evolving agent optimized for token efficiency.
