AutoGPT

Enables users to design autonomous agent workflows by dragging and dropping typed blocks (nodes) onto a canvas and connecting them with edges to define data flow. Built on React Flow for graph visualization with Zustand state management, supporting real-time graph serialization to JSON representing directed acyclic graphs (DAGs) of agent logic. The frontend communicates with a FastAPI backend that validates graph topology, manages block schemas via JSON Schema, and executes workflows through a distributed execution system.

Executes agent workflows across distributed workers by decomposing the DAG into individual block tasks, queuing them via RabbitMQ message broker, and managing execution state through a centralized scheduler. The execution system tracks block inputs/outputs, handles inter-block data passing, manages credit consumption per execution, and provides WebSocket-based real-time status updates to clients. Supports both synchronous and asynchronous block execution with configurable timeouts and retry policies.

Provides a centralized marketplace where users can publish, discover, and install pre-built blocks and agent templates. Blocks are versioned, include documentation and usage examples, and can be rated/reviewed by the community. The library system manages block dependencies, handles version conflicts, and enables one-click installation into user projects. Supports both public blocks (shared with all users) and private blocks (team-only). Includes a search interface with filtering by category, rating, and compatibility.

Manages sensitive credentials (API keys, database passwords, OAuth tokens) for blocks and integrations with encryption at rest and in transit. Each user has isolated credential storage; credentials are encrypted with user-specific keys and never exposed to other users or the platform. Blocks reference credentials by name (e.g., 'openai_key') rather than storing them directly, enabling secure credential rotation without updating workflows. Supports credential expiration, audit logging of credential access, and integration with external secret managers (AWS Secrets Manager, HashiCorp Vault).

Provides real-time visibility into agent execution through WebSocket connections that stream execution events (block started, completed, failed) to connected clients. Clients receive structured JSON events containing block name, status, inputs, outputs, and timing information. Enables live dashboards showing execution progress, intermediate results, and error details. Supports filtering events by block type or execution ID. Includes execution history storage for post-execution analysis and debugging.

Implements a credit system where each block execution consumes credits based on complexity, LLM token usage, and external API calls. Credits are allocated to users, tracked per execution, and deducted from user balances. The system calculates credit costs based on configurable rates per block type and LLM provider. Includes usage reports showing credit consumption over time, cost breakdowns by block type, and alerts when users approach credit limits. Supports credit packages (e.g., 1000 credits for $10) and subscription-based credit allocation.

Automatically generates user input forms for blocks using React JSON Schema Form (RJSF) by parsing block definitions containing JSON Schema specifications. Each block declares its input parameters, types, validation rules, and UI hints (e.g., dropdown options, text area vs input field) in a schema object. The system validates user inputs against schemas before execution, provides IDE-like autocomplete for block connections, and enables dynamic field visibility based on conditional schema rules (e.g., show API key field only if auth type is 'API').

Abstracts LLM provider differences through a unified block interface that supports OpenAI, Anthropic, Ollama, and other providers via a provider registry pattern. Blocks declare their LLM requirements (model name, temperature, max tokens) in schema, and the execution system routes requests to the configured provider at runtime. Handles provider-specific response formats, token counting, cost calculation, and fallback logic when a provider is unavailable. Credentials are encrypted and stored per-user, enabling multi-tenant deployments where each user configures their own API keys.

Implements a reasoning loop where the agent generates thoughts, decides which tools/blocks to invoke, executes them, observes results, and iterates until reaching a goal or max iterations. The loop is driven by an LLM that receives the current state (available blocks, previous results, user goal) as context and outputs structured decisions (which block to call, with what parameters). Supports both deterministic block chains (DAGs) and dynamic agentic loops where the LLM decides execution order at runtime. Includes memory management to track intermediate results and prevent infinite loops via iteration limits.

Integrates web search and page scraping capabilities as executable blocks within agent workflows, allowing agents to fetch real-time information from the internet. Blocks handle URL fetching, HTML parsing, and search query execution through configured search providers. Results are returned as structured data (text, links, metadata) that subsequent blocks can process. Includes rate limiting, timeout handling, and user-agent rotation to avoid blocking. Supports both direct URL access and search-based discovery of relevant pages.

Allows agents to execute arbitrary Python code within a sandboxed environment as part of workflows. Code blocks receive input parameters, execute Python code with access to common libraries (pandas, numpy, requests), and return results. Execution is isolated from the main process using containerization or subprocess isolation to prevent malicious code from affecting the system. Includes timeout enforcement, memory limits, and output capture. Supports both inline code strings and references to uploaded Python files.

Enables agents to read, write, and manipulate files as part of workflows through dedicated blocks. Supports creating text files, reading file contents, appending data, and organizing files in directories. Files are stored in a user-isolated storage backend (local filesystem or cloud storage) with access control. Agents can generate artifacts (reports, code, data) and make them available for download or further processing. Includes file type validation and size limits to prevent abuse.

Provides a standardized testing framework for evaluating agent performance against predefined tasks and metrics. Includes a test suite with diverse tasks (coding, reasoning, web search, etc.), automated evaluation of agent outputs against expected results, and performance metrics (success rate, token usage, cost). Supports both deterministic checks (exact match, regex) and LLM-based evaluation (does the output accomplish the goal?). Results are aggregated and compared across agent versions to track improvements.

Provides a Python SDK and development framework for building custom autonomous agents with minimal boilerplate. Includes base classes for agent implementation, decorators for tool registration, utilities for prompt engineering, and integration with the Agent Protocol standard. Developers write agent logic in Python, and Forge handles communication with the execution environment, tool invocation, and result formatting. Supports both simple agents (single LLM call) and complex agents (multi-step reasoning loops).