AutoGPT - Autonomous AI Agent Platform

Overview

AutoGPT is a comprehensive platform for building, deploying, and managing autonomous AI agents that execute continuously without human intervention. Unlike prompt-and-respond LLM wrappers, AutoGPT agents persist as long-running processes capable of reacting to webhooks, cron schedules, and external events. The platform ships with a visual drag-and-drop graph editor (the "Agent Builder"), a modular block system for composing logic, a marketplace for sharing pre-built agents, and a developer-focused Forge toolkit for custom agent creation.

AutoGPT matters because it bridges the gap between experimental AI agent prototypes and production-grade autonomous systems. Teams that need agents running 24/7 -- monitoring repositories, processing incoming data, or orchestrating multi-step business workflows -- get a battle-tested execution engine backed by PostgreSQL, Redis, and RabbitMQ, with built-in credential management and observability.

When to Use

Building autonomous agents that run continuously on schedules or webhook triggers
Creating visual, node-based AI workflows without writing code
Deploying multi-step automation pipelines that chain LLM calls with external integrations
Prototyping agent ideas quickly in a drag-and-drop editor before hardening them
Sharing reusable agent components through a marketplace
Benchmarking agent performance with standardized evaluation suites
Orchestrating complex flows involving GitHub, Google Workspace, Discord, Notion, and other SaaS tools
Running self-hosted agent infrastructure where you control execution and data

Quick Start

Docker Installation (recommended)


# Clone the repository
git clone https://github.com/Significant-Gravitas/AutoGPT.git
cd AutoGPT/autogpt_platform

# Configure environment
cp .env.example .env
# Edit .env to add your API keys:
#   OPENAI_API_KEY=sk-...
#   ANTHROPIC_API_KEY=sk-ant-...

# Launch all backend services (Postgres, Redis, RabbitMQ, API, executor)
docker compose up -d --build

# In a separate terminal, start the frontend
cd frontend
cp .env.example .env
npm install
npm run dev

Verify the deployment


# Check all containers are healthy
docker compose ps

# Test the API
curl http://localhost:8006/api/health
# Expected: {"status": "ok"}

# Open the UI
open http://localhost:3000

Access points

Service	URL	Purpose
Frontend UI	`http://localhost:3000`	Visual agent builder
REST API	`http://localhost:8006/api`	Programmatic access
WebSocket	`ws://localhost:8001/ws`	Real-time execution updates
RabbitMQ Admin	`http://localhost:15672`	Queue monitoring (guest/guest)

Architecture

AutoGPT is split into two major subsystems designed for different audiences:

AutoGPT Platform (production workflows)

The Platform is the production-grade system. It consists of a React + Next.js frontend, a FastAPI backend, and an asynchronous executor service. Agents are stored as directed graphs in PostgreSQL. When triggered, the execution engine traverses the graph node-by-node, queuing work through RabbitMQ and caching intermediate results in Redis.

┌────────────────────────────────────────────────────────────┐
│                      Frontend (React)                      │
│  Agent Builder  |  Marketplace  |  Execution Monitor       │
└────────────┬───────────────────────────┬───────────────────┘
             │ REST / WebSocket          │
┌────────────▼───────────────────────────▼───────────────────┐
│                   Backend (FastAPI)                         │
│  Graph CRUD  |  Auth  |  Credential Vault  |  Scheduling   │
└──────┬──────────────────┬──────────────────┬───────────────┘
       │                  │                  │
  PostgreSQL           Redis           RabbitMQ
       │                  │                  │
       └──────────────────┴──────────────────┘
                          │
              ┌───────────▼────────────┐
              │   Executor Service     │
              │  (graph traversal,     │
              │   block execution,     │
              │   output routing)      │
              └────────────────────────┘

AutoGPT Classic (development & experimentation)

Classic provides the Forge toolkit for building agents in Python, a CLI for running them, and a benchmark suite (agbenchmark) for standardized evaluation. This is ideal for researchers and developers who want fine-grained control over agent behavior.

classic/
├── forge/          # Agent development SDK
├── benchmark/      # agbenchmark evaluation suite
├── cli/            # Command-line runner
└── agents/         # Sample agent implementations

Core Concepts

Graphs and Nodes

Every agent is a Graph -- a directed acyclic graph of Nodes. Each Node wraps a Block (the unit of execution). Nodes are connected by Links that define data flow.

Graph (Agent: "PR Review Bot")
  ├── Node: webhook_trigger
  │   └── Block: WebhookTriggerBlock
  ├── Node: fetch_pr
  │   └── Block: GitHubPRFetchBlock
  ├── Node: analyze_code
  │   └── Block: AITextGeneratorBlock
  ├── Node: post_comment
  │   └── Block: GitHubCommentBlock
  └── Node: output
      └── Block: AgentOutputBlock

Block System

Blocks are the atomic building units. Each block has typed inputs, typed outputs, and an execute() method.

Block Category	Examples	Purpose
`INPUT`	`AgentInputBlock`, `WebhookTriggerBlock`	Entry points for data
`OUTPUT`	`AgentOutputBlock`	Final results
`AI`	`AITextGeneratorBlock`, `AIConversationBlock`, `SmartDecisionMakerBlock`	LLM reasoning
`INTEGRATION`	`GitHubBlock`, `GoogleSheetsBlock`, `NotionBlock`, `DiscordBlock`	SaaS connectors
`STANDARD`	`TextFormatterBlock`, `JSONParserBlock`, `HTTPRequestBlock`	General operations
`CONTROL`	`BranchBlock`, `LoopBlock`, `MergeBlock`	Flow control
`AGENT`	`AgentExecutorBlock`	Nested agent invocation

Execution Model

Trigger (webhook / schedule / manual)
    │
    ▼
Graph Execution Created (UUID assigned)
    │
    ▼
Nodes enqueued to RabbitMQ in topological order
    │
    ▼
Executor picks up each node:
    1. Resolve inputs from upstream outputs
    2. Call block.execute(inputs)
    3. Yield outputs
    4. Enqueue downstream nodes
    │
    ▼
WebSocket pushes status updates to UI
    │
    ▼
Execution completes → results persisted to PostgreSQL

Building Agents

Visual Builder Workflow

Navigate to http://localhost:3000 and click New Agent
From the blocks panel on the left, drag an Input Block onto the canvas
Add processing blocks (e.g., AITextGeneratorBlock) and connect them
Configure each block by clicking it and filling in parameters
Add an Output Block to capture results
Click Run to test with sample inputs
Click Deploy to enable webhook/schedule triggers

Programmatic Agent Creation via API


# Create a new graph
curl -X POST http://localhost:8006/api/v1/graphs \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Code Analyzer",
    "description": "Analyzes code quality from GitHub PRs",
    "nodes": [
      {
        "id": "input_1",
        "block_id": "agent_input",
        "metadata": {"position": {"x": 0, "y": 0}},
        "input_default": {"name": "pr_url", "type": "string"}
      },
      {
        "id": "llm_1",
        "block_id": "ai_text_generator",
        "metadata": {"position": {"x": 300, "y": 0}},
        "input_default": {
          "prompt": "Analyze this pull request for code quality issues: {pr_content}",
          "model": "gpt-4o"
        }
      },
      {
        "id": "output_1",
        "block_id": "agent_output",
        "metadata": {"position": {"x": 600, "y": 0}}
      }
    ],
    "links": [
      {"source_id": "input_1", "sink_id": "llm_1", "source_name": "value", "sink_name": "pr_content"},
      {"source_id": "llm_1", "sink_id": "output_1", "source_name": "response", "sink_name": "value"}
    ]
  }'

Trigger Types

Manual execution:


curl -X POST http://localhost:8006/api/v1/graphs/{graph_id}/execute \
  -H "Content-Type: application/json" \
  -d '{"inputs": {"pr_url": "https://github.com/org/repo/pull/42"}}'

Webhook trigger:


# Register webhook
curl -X POST http://localhost:8006/api/v1/webhooks \
  -d '{"graph_id": "abc-123", "event_type": "github.pull_request"}'

# GitHub sends events to:
# POST http://your-server:8006/api/v1/webhooks/{webhook_id}

Scheduled execution (cron):


{
  "schedule": "0 9 * * 1-5",
  "graph_id": "abc-123",
  "inputs": {"report_type": "daily"}
}

Monitoring Execution in Real Time


// Connect to WebSocket for live updates
const ws = new WebSocket('ws://localhost:8001/ws');

ws.onmessage = (event) => {
  const update = JSON.parse(event.data);
  switch (update.status) {
    case 'running':
      console.log(`Node ${update.node_id} executing...`);
      break;
    case 'completed':
      console.log(`Node ${update.node_id} output:`, update.output);
      break;
    case 'failed':
      console.error(`Node ${update.node_id} error:`, update.error);
      break;
  }
};

Using Forge (Custom Agent Development)

Scaffold a new agent


cd classic
./run setup              # Install dependencies
./run forge create my-research-agent   # Scaffold from template
./run forge start my-research-agent    # Start the agent server

Agent project structure

my-research-agent/
├── agent.py              # Main agent logic and lifecycle
├── abilities/
│   ├── __init__.py
│   ├── web_search.py     # Custom web search ability
│   └── summarize.py      # Custom summarization ability
├── prompts/
│   ├── system.txt        # System prompt template
│   └── task.txt          # Task prompt template
└── config.yaml           # Agent configuration

Implementing a custom ability


from forge import Ability, ability

@ability(
    name="analyze_repository",
    description="Clone and analyze a GitHub repository for code quality",
    parameters={
        "repo_url": {"type": "string", "description": "GitHub repository URL"},
        "focus_areas": {"type": "array", "description": "Areas to focus on", "items": {"type": "string"}}
    }
)
async def analyze_repository(repo_url: str, focus_areas: list[str] = None) -> str:
    """Clone repo, run static analysis, and return findings."""
    import subprocess
    import tempfile
    import os

    with tempfile.TemporaryDirectory() as tmp:
        subprocess.run(["git", "clone", "--depth=1", repo_url, tmp], check=True)

        findings = []
        for root, dirs, files in os.walk(tmp):
            for f in files:
                if f.endswith(".py"):
                    path = os.path.join(root, f)
                    result = subprocess.run(
                        ["python", "-m", "py_compile", path],
                        capture_output=True, text=True
                    )
                    if result.returncode != 0:
                        findings.append(f"Syntax error in {f}: {result.stderr}")

        return f"Analyzed {repo_url}. Found {len(findings)} issues.\n" + "\n".join(findings)

Benchmarking Agents


# Run the full benchmark suite
./run benchmark

# Run a specific category
./run benchmark --category coding

# Benchmark a specific agent
./run benchmark --agent my-research-agent

# Record HTTP cassettes for reproducibility
./run benchmark --record

# Replay from recorded cassettes
./run benchmark --playback

Benchmark categories

Category	Description	Example Tasks
Coding	Code generation, debugging	"Write a Python sort function"
Retrieval	Information extraction	"Find the CEO of Company X"
Web	Web navigation and interaction	"Book a flight on website Y"
Writing	Content generation	"Write a blog post about Z"

Configuration Reference

Environment Variables

Variable	Required	Description
`DATABASE_URL`	Yes	PostgreSQL connection string
`REDIS_URL`	Yes	Redis connection string
`RABBITMQ_URL`	Yes	RabbitMQ connection string
`ENCRYPTION_KEY`	Yes	Key for credential encryption
`SUPABASE_URL`	No	Authentication provider URL
`SUPABASE_ANON_KEY`	No	Supabase anonymous key
`OPENAI_API_KEY`	No	OpenAI API key for LLM blocks
`ANTHROPIC_API_KEY`	No	Anthropic API key for Claude blocks
`GITHUB_TOKEN`	No	GitHub personal access token
`SENTRY_DSN`	No	Error tracking

Generate encryption key


cd autogpt_platform/backend
poetry run cli gen-encrypt-key
# Output: Add ENCRYPTION_KEY=<generated> to your .env

Production Deployment


# docker-compose.prod.yml
version: '3.8'
services:
  postgres:
    image: postgres:16
    environment:
      POSTGRES_DB: autogpt
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - pgdata:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    command: redis-server --requirepass ${REDIS_PASSWORD}

  rabbitmq:
    image: rabbitmq:3-management
    environment:
      RABBITMQ_DEFAULT_USER: autogpt
      RABBITMQ_DEFAULT_PASS: ${RABBITMQ_PASSWORD}

  rest_server:
    image: autogpt/platform-backend:latest
    environment:
      DATABASE_URL: postgresql://postgres:${DB_PASSWORD}@postgres/autogpt
      REDIS_URL: redis://:${REDIS_PASSWORD}@redis:6379
      RABBITMQ_URL: amqp://autogpt:${RABBITMQ_PASSWORD}@rabbitmq
      ENCRYPTION_KEY: ${ENCRYPTION_KEY}
    ports:
      - "8006:8006"
    depends_on: [postgres, redis, rabbitmq]

  executor:
    image: autogpt/platform-backend:latest
    command: poetry run executor
    environment:
      DATABASE_URL: postgresql://postgres:${DB_PASSWORD}@postgres/autogpt
      REDIS_URL: redis://:${REDIS_PASSWORD}@redis:6379
      RABBITMQ_URL: amqp://autogpt:${RABBITMQ_PASSWORD}@rabbitmq
    depends_on: [postgres, redis, rabbitmq]

  frontend:
    image: autogpt/platform-frontend:latest
    ports:
      - "3000:3000"
    environment:
      NEXT_PUBLIC_API_URL: https://api.yourdomain.com

volumes:
  pgdata:

Best Practices

Start with small graphs. Build agents with 3-5 nodes and validate they work before adding complexity. A single misbehaving node in a 20-node graph is painful to debug.
Test incrementally. After adding or modifying each node, run the agent with sample inputs. Use the execution monitor to verify each node produces expected output.
Use webhooks over polling. Event-driven triggers (webhooks, queue messages) are more efficient than scheduled polling. Reserve cron schedules for periodic summaries or batch processing.
Encrypt and rotate credentials. Never hardcode API keys in agent configurations. Use the built-in credential vault and rotate the ENCRYPTION_KEY periodically.
Monitor queue depth. Watch the RabbitMQ admin panel (http://localhost:15672). Growing queues indicate the executor cannot keep up -- scale horizontally by running additional executor containers.
Version your agents. Save working graph configurations before making changes. The platform supports graph versioning; use it to roll back when experiments fail.
Set execution timeouts. Configure per-node and per-graph timeouts to prevent runaway agents from consuming unlimited resources and API credits.
Benchmark before deploying. Use agbenchmark to validate agent quality on standardized tasks. Track benchmark scores over time as you iterate.
Separate development and production. Run a local Docker stack for development and a separate production deployment. Use different database instances and API keys.
Log everything. Enable verbose logging during development. In production, ship logs to a centralized system (ELK, Datadog) for debugging execution failures.

Troubleshooting

Services fail to start:


# Check container status and logs
docker compose ps
docker compose logs rest_server
docker compose logs executor

# Common fix: database not ready yet
docker compose restart rest_server

Database migration errors:


cd autogpt_platform/backend
poetry run prisma migrate deploy
# If migrations are stuck:
poetry run prisma migrate reset  # WARNING: drops all data

Agent execution hangs:


# Check RabbitMQ for stuck messages
# Open http://localhost:15672 (guest/guest)
# Look at Queues tab for unacknowledged messages

# Force-restart the executor
docker compose restart executor

WebSocket not connecting:


# Verify the WebSocket server is running
curl -i http://localhost:8001/health

# Check CORS settings in .env
# Ensure ALLOWED_ORIGINS includes your frontend URL

Out of memory on large graphs:


# Increase executor memory limit
# In docker-compose.yml:
executor:
  deploy:
    resources:
      limits:
        memory: 4G

Comparison with Alternatives

Feature	AutoGPT	CrewAI	LangChain	LlamaIndex
Primary focus	Autonomous agents	Multi-agent teams	General LLM apps	RAG / data retrieval
Visual builder	Yes (full UI)	No	No	No
Continuous execution	Yes (triggers)	No (batch)	No (batch)	No (batch)
No-code option	Yes	No	No	No
Custom blocks	Python SDK	Python	Python	Python
Marketplace	Yes	No	LangChain Hub	LlamaHub
Self-hosted	Docker stack	pip install	pip install	pip install
Best for	Always-on automation	Role-based collaboration	Prototyping + RAG	Document Q&A

Resources

Documentation: https://docs.agpt.co
Repository: https://github.com/Significant-Gravitas/AutoGPT
Discord: https://discord.gg/autogpt
License: MIT (Classic) / Polyform Shield (Platform)

Pro Agents Autogpt