BabyAGI

Registers Python functions using @register_function() decorator that captures metadata including descriptions, dependencies, imports, and key dependencies into a centralized registry. The decorator introspects function signatures and stores them in a database-backed function store, enabling the system to resolve dependencies and manage execution without manual configuration. This approach decouples function definition from function management infrastructure.

Analyzes user-provided natural language descriptions using an LLM to determine whether to reuse existing functions or generate new ones, then generates Python code that implements the required functionality. The system uses prompt engineering to guide the LLM through code generation, dependency identification, and function signature creation. Generated functions are automatically registered into the function store and can be immediately executed.

Uses an LLM to automatically generate clear, structured descriptions of functions based on their code and docstrings. The system analyzes function signatures, parameter types, return types, and implementation to create descriptions suitable for agent reasoning and human understanding. Generated descriptions are stored in the function registry and used for semantic search and function selection.

Records detailed execution history for each function invocation including start time, end time, duration, parameters, results, and error information. The system tracks performance metrics (latency, success rate) per function and provides aggregated statistics. Execution history is queryable and can be used for debugging, performance optimization, and understanding agent behavior patterns.

Resolves function dependencies declared in metadata by analyzing the function registry and constructing execution graphs that respect import requirements and function call chains. When executing a function, the system automatically loads required dependencies, manages imports, and ensures all prerequisite functions are available. This enables complex multi-step operations where functions can depend on other functions without manual orchestration.

Implements a Reasoning + Acting (ReAct) agent pattern that uses an LLM to reason about which functions to call based on user input, then executes selected functions and observes results. The agent maintains a thought-action-observation loop where it generates reasoning steps, selects functions from the registry based on semantic matching, executes them, and incorporates results into subsequent reasoning. Function selection uses embeddings or semantic matching to find relevant functions from the registry.

Implements an agent that can autonomously decide whether to use existing functions or generate new ones to accomplish tasks. The agent evaluates available functions in the registry against task requirements, and if no suitable function exists, it triggers the LLM-driven code generation system to create a new function, registers it, and then executes it. This creates a feedback loop where the agent's capabilities expand as it encounters new task types.

Generates semantic embeddings for function descriptions using an LLM or embedding model, enabling semantic search across the function registry. When an agent needs to find relevant functions for a task, it can search the registry using natural language queries rather than exact name matching. The system computes embedding similarity between the query and function descriptions to rank and retrieve the most relevant functions.

Provides a web UI for viewing registered functions, their metadata, dependencies, and execution history. The dashboard visualizes function relationships as a dependency graph, displays execution logs with timing and error information, and allows users to manually trigger function execution. It also provides interfaces for managing secret keys and environment configuration without exposing sensitive data in logs.

Exposes HTTP endpoints for registering functions, querying the function registry, triggering function execution, and retrieving execution results. The API allows external systems to interact with BabyAGI without direct Python access, enabling integration with other tools and services. Endpoints support both synchronous execution (wait for results) and asynchronous execution (poll for status).

Manages API keys, database credentials, and other secrets used by functions without exposing them in logs or code. Secrets are stored encrypted in a secure store (not in plaintext in function code) and injected into function execution contexts at runtime. The system prevents accidental logging of secrets and provides audit trails for secret access.

Enables functions to be triggered by events (HTTP webhooks, scheduled timers, function completion events) rather than only on-demand. The system maintains an event queue and routes events to registered trigger handlers. Functions can declare triggers in their metadata, and the execution engine automatically invokes them when matching events occur. This enables reactive workflows where functions respond to external events.