Mini AGI

Implements a continuous execution loop where the agent generates thoughts via LLM, selects and executes commands, processes observations, and optionally applies self-criticism to refine behavior. The loop maintains state across iterations through a MiniAGI orchestrator class that coordinates ThinkGPT instances for reasoning and action generation, enabling multi-step task decomposition without external orchestration frameworks.

Maintains a summarized_history buffer that condenses lengthy observations and action sequences to stay within a configurable MAX_CONTEXT_SIZE token limit. When observations exceed MAX_MEMORY_ITEM_SIZE, the summarizer ThinkGPT instance compresses them; when total history grows, older items are summarized and replaced. This approach preserves semantic meaning of past actions while freeing tokens for new reasoning, implemented via explicit summarization calls rather than sliding-window or retrieval-based approaches.

The agent is initialized with a user-provided objective (goal) and uses the think-act-criticize loop to decompose it into sub-tasks and execute them sequentially. The LLM reasons about what steps are needed to achieve the objective, selects appropriate commands, and iterates until the objective is complete (signaled by the done command). This approach enables flexible, adaptive task decomposition without requiring explicit task graphs or workflows.

MiniAGI can be deployed in a Docker container with environment variables and dependencies pre-configured. The Dockerfile specifies Python runtime, dependency installation, and entry point configuration, enabling reproducible agent execution across different environments. This provides OS-level isolation and dependency management without requiring manual setup.

Provides a Commands class that exposes six executable actions: execute_python (runs arbitrary Python code in the agent's process), execute_shell (runs bash/shell commands), web_search (queries the web for information), talk_to_user (prompts for human input), ingest_data (loads files or URLs), and process_data (applies LLM-based transformation to data). The agent selects which command to execute based on LLM reasoning, and each command returns structured observations that feed back into the reasoning loop.

The agent's think() method prompts the LLM to generate a thought, proposed_command, and proposed_arg in a structured format. The LLM output is parsed to extract the command name and argument, which are then validated against the Commands registry and executed. This approach uses the LLM as a decision-making engine that reasons about which action to take next, rather than using predefined workflows or decision trees.

When ENABLE_CRITIC is set to true, the agent generates a criticism of its proposed action before execution, allowing it to reflect on whether the action is appropriate. The criticism is stored and can inform future decisions. This is implemented as an optional post-thinking step that calls the agent ThinkGPT instance again to evaluate the proposed command, adding an extra LLM call per step.

When PROMPT_USER is enabled (default true), the agent pauses before executing each command and prompts the user for approval via stdin. The user can approve the action, provide feedback, or reject it. This implements a human-in-the-loop mechanism that prevents the agent from executing unintended or dangerous commands without explicit authorization.

The agent and summarizer can be configured to use different OpenAI models via MODEL and SUMMARIZER_MODEL environment variables. This allows builders to optimize cost and performance by using cheaper models (e.g., GPT-3.5-turbo) for summarization and more capable models (e.g., GPT-4) for reasoning. The configuration is applied at initialization time and affects all subsequent LLM calls.

The ingest_data command loads data from files or URLs and returns the raw content. The process_data command takes ingested data and applies an LLM-based transformation using a user-provided prompt, enabling the agent to extract, summarize, or restructure data. This allows the agent to work with external data sources and apply semantic processing without requiring specialized data parsing libraries.

The WORK_DIR environment variable (default ~/miniagi) specifies a working directory where the agent operates. File operations and shell commands are scoped to this directory, providing basic isolation and preventing the agent from accidentally modifying files outside its intended scope. This is implemented via environment variable configuration rather than OS-level sandboxing.

When DEBUG is set to true, the agent prints detailed execution traces including thoughts, proposed commands, observations, and memory state to stdout. This provides visibility into the agent's decision-making process and helps developers understand why the agent is taking specific actions. Debug output is unstructured text rather than structured logs.