GenericAgent

Implements a core agent_runner_loop that orchestrates the sense-think-act cycle by accepting LLM responses, parsing tool calls from multiple backend protocols (OpenAI, Anthropic, Gemini), executing atomic tools, and feeding results back to the LLM in a closed feedback loop. The architecture abstracts backend differences through a unified LLM Communication Layer that normalizes function-calling schemas across providers, enabling seamless switching between Claude, GPT, and Gemini without code changes.

Implements a multi-layer memory architecture consisting of working memory (update_working_checkpoint), episodic memory (task execution logs), and long-term memory (crystallized procedures and learned SOPs). The system uses Core Axioms as governance rules that define how the agent thinks and operates, and triggers background memory refinement via start_long_term_update which distills repeated task patterns into reusable procedures. Memory operations are synchronized across layers to maintain consistency and prevent conflicting knowledge states.

The ask_user tool enables the agent to request human confirmation before executing irreversible or high-risk actions, implementing interactive decision gates in the agent's workflow. The tool blocks the agent loop until a human responds, allowing humans to inspect the agent's reasoning, provide corrections, or approve/reject proposed actions. This enables safe autonomous operation in domains where human oversight is required.

Implements robust error handling and retry logic that gracefully handles LLM API failures, tool execution errors, and network timeouts. The system uses provider-specific fallback strategies (e.g., exponential backoff for rate limits, circuit breakers for service outages) and can automatically retry failed operations with modified parameters. Error states are logged and fed back into the memory system for learning.

Provides 9 atomic tools (code_run, file_read, file_write, file_patch, web_scan, web_execute_js, ask_user, update_working_checkpoint, start_long_term_update) that give the LLM direct physical-level control over the computing system. The code_run tool executes Python or PowerShell code in isolated runtime contexts, enabling the agent to manufacture new tools dynamically, interact with the OS, and perform arbitrary computation. Each tool is designed as a minimal, composable primitive that can be combined to achieve complex tasks.

The web_scan tool extracts and tokenizes HTML content from web pages using intelligent pagination and token budgeting to minimize context window consumption. The system analyzes page structure, identifies relevant content regions, and returns compressed HTML representations that preserve semantic meaning while reducing token count by orders of magnitude. This enables the agent to perceive large web pages without exhausting the LLM's context window.

The web_execute_js tool injects and executes arbitrary JavaScript code in the browser's DOM context, enabling the agent to click elements, fill forms, scroll pages, and manipulate application state. The tool maintains synchronization between the agent's mental model of page state and the actual DOM state, returning execution results and updated page snapshots after each operation. This enables complex multi-step browser automation workflows.

The file_patch tool enables precise, surgical modifications to existing files using line-based diffing. Rather than rewriting entire files, it identifies the exact lines to modify, applies changes atomically, and validates the result. This approach minimizes token consumption (only changed lines are transmitted) and reduces the risk of corrupting files through accidental overwrites. The tool supports multi-line edits and preserves file formatting.

Implements an Autonomous Operation Framework that decomposes complex user requests into executable tasks using three execution modes: Task Mode (single sequential task), Map Mode (parallel processing of independent subtasks), and Plan Mode (complex multi-step workflows with dependencies). The system uses a Task Planning System that analyzes user intent, generates task decompositions, and orchestrates execution through subagent instances. Reports and learning loops feed task outcomes back into the memory system for future optimization.

Provides multiple user interface layers (Desktop UI via launch.pyw and Streamlit, CLI, Chat Platform Integrations, File-based Modes) that allow users to interact with the agent through their preferred channel. The system abstracts the underlying agent engine from UI concerns, enabling the same agent instance to be accessed via web browser, command line, Slack/WeChat, or file-based IPC. This enables flexible deployment across different organizational contexts.

Implements a self-evolution mechanism where the agent autonomously grows its capability set by recording learned procedures into the memory system as Standard Operating Procedures (SOPs). When the agent solves a novel task, it extracts the solution pattern, crystallizes it into a reusable procedure, and stores it in long-term memory. Future tasks can reference these learned SOPs, reducing token consumption and improving consistency. The skill tree grows organically from the initial 3K-line seed without manual intervention.

Implements working memory checkpoints (update_working_checkpoint tool) that compress multi-turn conversation history into concise summaries, enabling the agent to maintain context across long task sequences without exhausting the LLM's context window. The system tracks which information is essential for future reasoning, prunes irrelevant details, and stores compressed state that can be restored in subsequent turns. This achieves the project's claimed 6x token reduction compared to naive context accumulation.