BabyFoxAGI

Enables developers to register Python functions using @register_function() decorator that automatically captures function signatures, docstrings, dependencies, and imports into a centralized registry. The decorator introspects function metadata and stores it in a database-backed function store, enabling downstream systems to discover, validate, and execute functions without manual catalog maintenance. This approach decouples function definition from function management infrastructure.

Accepts natural language descriptions of desired functionality and uses an LLM (via prompt engineering) to analyze requirements, determine whether to reuse existing functions or generate new code, and produce executable Python functions that are automatically registered. The system generates function signatures, docstrings, and implementation code based on semantic understanding of the requirement, then validates the generated code before registration. This enables non-programmers and agents to expand system capabilities through conversation.

BabyFoxAGI-specific feature: Provides a side-by-side UI panel that displays agent execution in real-time alongside the main dashboard. The parallel panel shows the agent's reasoning trace, function selections, and execution results as they happen, enabling developers to monitor agent behavior without switching views. Updates are pushed to the UI via WebSocket or polling. The panel can be configured to show different levels of detail (reasoning only, function calls only, full trace).

Provides a secure store for API keys, database credentials, and other secrets used by functions. Secrets are stored encrypted in a database and injected into function execution contexts as environment variables or function parameters. The system prevents secrets from being logged or exposed in execution traces. Secrets can be scoped to specific functions or shared across multiple functions. Access to secrets can be restricted via permissions.

Automatically resolves function dependencies declared in function metadata and manages Python imports required for execution. When a function is executed, the system analyzes its dependency graph, ensures all required functions are available, and injects necessary imports into the execution context. This eliminates manual dependency management and enables functions to compose without explicit import statements. The system maintains a dependency DAG and detects circular dependencies.

Executes registered functions in isolated Python execution contexts with automatic dependency injection, error handling, and execution logging. The engine creates a sandboxed namespace for each function execution, injects required imports and dependencies, executes the function, captures output and errors, and logs execution metadata. This approach prevents namespace pollution and enables detailed execution tracing. The engine supports both synchronous and asynchronous function execution.

Implements a ReAct (Reasoning + Acting) agent that uses an LLM to reason about available functions, select appropriate functions to call based on task requirements, execute them, and iterate based on results. The agent maintains a reasoning trace showing thought process, function selections, and outcomes. It uses semantic matching between task descriptions and function descriptions to select relevant functions, then executes them and feeds results back into the reasoning loop. This creates a transparent, auditable decision-making process.

Extends the ReAct agent with the ability to generate new functions when existing functions are insufficient for a task. The agent analyzes task requirements, checks if existing functions can handle them, and if not, generates new functions using the LLM-based code generation system, registers them, and then executes them. This creates a feedback loop where agents can expand their own capability surface. The system tracks which functions were generated vs. pre-existing.

Provides a web UI for viewing registered functions, their metadata, dependencies, and execution history. The dashboard visualizes function relationships as a dependency graph, allows manual function execution with parameter input, displays execution logs and results, and provides secret key management. The interface is built with a modern web framework and communicates with the BabyAGI backend via REST API. Real-time updates show execution status and logs.

Exposes BabyAGI functionality via REST endpoints for function registration, querying, execution, and monitoring. The API supports CRUD operations on functions, querying by description or metadata, triggering function execution with parameters, and retrieving execution history. Responses are JSON-formatted with structured metadata. The API enables external systems and tools to integrate with BabyAGI without direct Python access. Authentication can be configured per deployment.

Generates embeddings for function descriptions and enables semantic search to find relevant functions based on task descriptions. When a task is provided, the system converts it to an embedding and finds the most similar function descriptions using vector similarity. This enables agents to discover functions without exact keyword matching. Embeddings are cached to avoid recomputation. The system supports multiple embedding models and vector similarity metrics.

Enables functions to be triggered automatically based on events such as time schedules, webhook calls, or completion of other functions. Triggers are defined declaratively with conditions and actions. When a trigger condition is met, the associated function is automatically executed with specified parameters. The system maintains a trigger registry and execution history. Triggers can be chained to create complex automation workflows.