autogpt-agents
Autonomous AI agent platform for building and deploying continuous agents. Use when creating visual workflow agents, deploying persistent autonomous agents, or building complex multi-step AI automation systems.
Install this skill
Works with Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode, and 70+ other harnesses.
npx skills add KalarisLabs/research-agent-skills --skill autogpt-agentsuvx research-agent-skills install autogpt-agentsDocumentation & Instructions
AutoGPT - Autonomous AI Agent Platform
Comprehensive platform for building, deploying, and managing continuous AI agents through a visual interface or development toolkit.
When to use AutoGPT
Use AutoGPT when:
- Building autonomous agents that run continuously
- Creating visual workflow-based AI agents
- Deploying agents with external triggers (webhooks, schedules)
- Building complex multi-step automation pipelines
- Need a no-code/low-code agent builder
Key features:
- Visual Agent Builder: Drag-and-drop node-based workflow editor
- Continuous Execution: Agents run persistently with triggers
- Marketplace: Pre-built agents and blocks to share/reuse
- Block System: Modular components for LLM, tools, integrations
- Forge Toolkit: Developer tools for custom agent creation
- Benchmark System: Standardized agent performance testing
Use alternatives instead:
- LangChain/LlamaIndex: If you need more control over agent logic
- CrewAI: For role-based multi-agent collaboration
- OpenAI Assistants: For simple hosted agent deployments
- Semantic Kernel: For Microsoft ecosystem integration
Quick start
Installation (Docker)
# Clone repository
git clone https://github.com/Significant-Gravitas/AutoGPT.git
cd AutoGPT/autogpt_platform
# Copy environment file
cp .env.example .env
# Start backend services
docker compose up -d --build
# Start frontend (in separate terminal)
cd frontend
cp .env.example .env
npm install
npm run dev
Access the platform
- Frontend UI: http://localhost:3000
- Backend API: http://localhost:8006/api
- WebSocket: ws://localhost:8001/ws
Architecture overview
AutoGPT has two main systems:
AutoGPT Platform (Production)
- Visual agent builder with React frontend
- FastAPI backend with execution engine
- PostgreSQL + Redis + RabbitMQ infrastructure
AutoGPT Classic (Development)
- Forge: Agent development toolkit
- Benchmark: Performance testing framework
- CLI: Command-line interface for development
Core concepts
Graphs and nodes
Agents are represented as graphs containing nodes connected by links:
Graph (Agent)
├── Node (Input)
│ └── Block (AgentInputBlock)
├── Node (Process)
│ └── Block (LLMBlock)
├── Node (Decision)
│ └── Block (SmartDecisionMaker)
└── Node (Output)
└── Block (AgentOutputBlock)
Blocks
Blocks are reusable functional components:
| Block Type | Purpose |
|---|---|
INPUT |
Agent entry points |
OUTPUT |
Agent outputs |
AI |
LLM calls, text generation |
WEBHOOK |
External triggers |
STANDARD |
General operations |
AGENT |
Nested agent execution |
Execution flow
User/Trigger → Graph Execution → Node Execution → Block.execute()
↓ ↓ ↓
Inputs Queue System Output Yields
Building agents
Using the visual builder
- Open Agent Builder at http://localhost:3000
- Add blocks from the BlocksControl panel
- Connect nodes by dragging between handles
- Configure inputs in each node
- Run agent using PrimaryActionBar
Available blocks
AI Blocks:
AITextGeneratorBlock- Generate text with LLMsAIConversationBlock- Multi-turn conversationsSmartDecisionMakerBlock- Conditional logic
Integration Blocks:
- GitHub, Google, Discord, Notion connectors
- Webhook triggers and handlers
- HTTP request blocks
Control Blocks:
- Input/Output blocks
- Branching and decision nodes
- Loop and iteration blocks
Agent execution
Trigger types
Manual execution:
POST /api/v1/graphs/{graph_id}/execute
Content-Type: application/json
{
"inputs": {
"input_name": "value"
}
}
Webhook trigger:
POST /api/v1/webhooks/{webhook_id}
Content-Type: application/json
{
"data": "webhook payload"
}
Scheduled execution:
{
"schedule": "0 */2 * * *",
"graph_id": "graph-uuid",
"inputs": {}
}
Monitoring execution
WebSocket updates:
const ws = new WebSocket('ws://localhost:8001/ws');
ws.onmessage = (event) => {
const update = JSON.parse(event.data);
console.log(`Node ${update.node_id}: ${update.status}`);
};
REST API polling:
GET /api/v1/executions/{execution_id}
Using Forge (Development)
Create custom agent
# Setup forge environment
cd classic
./run setup
# Create new agent from template
./run forge create my-agent
# Start agent server
./run forge start my-agent
Agent structure
my-agent/
├── agent.py # Main agent logic
├── abilities/ # Custom abilities
│ ├── __init__.py
│ └── custom.py
├── prompts/ # Prompt templates
└── config.yaml # Agent configuration
Implement custom ability
from forge import Ability, ability
@ability(
name="custom_search",
description="Search for information",
parameters={
"query": {"type": "string", "description": "Search query"}
}
)
def custom_search(query: str) -> str:
"""Custom search ability."""
# Implement search logic
result = perform_search(query)
return result
Benchmarking agents
Run benchmarks
# Run all benchmarks
./run benchmark
# Run specific category
./run benchmark --category coding
# Run with specific agent
./run benchmark --agent my-agent
Benchmark categories
- Coding: Code generation and debugging
- Retrieval: Information finding
- Web: Web browsing and interaction
- Writing: Text generation tasks
VCR cassettes
Benchmarks use recorded HTTP responses for reproducibility:
# Record new cassettes
./run benchmark --record
# Run with existing cassettes
./run benchmark --playback
Integrations
Adding credentials
- Navigate to Profile > Integrations
- Select provider (OpenAI, GitHub, Google, etc.)
- Enter API keys or authorize OAuth
- Credentials are encrypted and stored securely
Using credentials in blocks
Blocks automatically access user credentials:
class MyLLMBlock(Block):
def execute(self, inputs):
# Credentials are injected by the system
credentials = self.get_credentials("openai")
client = OpenAI(api_key=credentials.api_key)
# ...
Supported providers
| Provider | Auth Type | Use Cases |
|---|---|---|
| OpenAI | API Key | LLM, embeddings |
| Anthropic | API Key | Claude models |
| GitHub | OAuth | Code, repos |
| OAuth | Drive, Gmail, Calendar | |
| Discord | Bot Token | Messaging |
| Notion | OAuth | Documents |
Deployment
Docker production setup
# docker-compose.prod.yml
services:
rest_server:
image: autogpt/platform-backend
environment:
- DATABASE_URL=postgresql://...
- REDIS_URL=redis://redis:6379
ports:
- "8006:8006"
executor:
image: autogpt/platform-backend
command: poetry run executor
frontend:
image: autogpt/platform-frontend
ports:
- "3000:3000"
Environment variables
| Variable | Purpose |
|---|---|
DATABASE_URL |
PostgreSQL connection |
REDIS_URL |
Redis connection |
RABBITMQ_URL |
RabbitMQ connection |
ENCRYPTION_KEY |
Credential encryption |
SUPABASE_URL |
Authentication |
Generate encryption key
cd autogpt_platform/backend
poetry run cli gen-encrypt-key
Best practices
- Start simple: Begin with 3-5 node agents
- Test incrementally: Run and test after each change
- Use webhooks: External triggers for event-driven agents
- Monitor costs: Track LLM API usage via credits system
- Version agents: Save working versions before changes
- Benchmark: Use agbenchmark to validate agent quality
Common issues
Services not starting:
# Check container status
docker compose ps
# View logs
docker compose logs rest_server
# Restart services
docker compose restart
Database connection issues:
# Run migrations
cd backend
poetry run prisma migrate deploy
Agent execution stuck:
# Check RabbitMQ queue
# Visit http://localhost:15672 (guest/guest)
# Clear stuck executions
docker compose restart executor
References
- Advanced Usage - Custom blocks, deployment, scaling
- Troubleshooting - Common issues, debugging
Resources
- Documentation: https://docs.agpt.co
- Repository: https://github.com/Significant-Gravitas/AutoGPT
- Discord: https://discord.gg/autogpt
- License: MIT (Classic) / Polyform Shield (Platform)
Agent operating procedure
- Check the environment. Confirm the framework version, model provider, API keys and rate limits.
- Pin down the inputs. Confirm formats, identifiers and parameters from the data or the user. Ask rather than guess any value that changes the result.
- Run a small version first. Test a single call or chain with a known input and inspect raw outputs.
- Execute the full task using the instructions and references above.
- Validate the result. Evaluate on a small labeled set; check structured outputs against their schema; log prompts and responses.
- Report. State what was run (versions, commands, parameters), what was checked, and what is still uncertain.
| If this happens | Do this |
|---|---|
| Outputs do not match the expected schema | Add validation and retries, tighten the schema, or simplify the prompt. |
| A function, flag or endpoint in these instructions is missing in the installed version | Check the installed version's own documentation (help(), --help, official docs), adapt, and tell the user. Never invent an API. |
| A required input, identifier or parameter is ambiguous | Ask the user, or state the assumption explicitly before running. |
Integrity rules
- Never fabricate results, parameters, identifiers, citations or statistics. If something cannot be run or verified, say so plainly.
- Never send private or sensitive data to external APIs without the user's consent.
- Treat version-specific details here as possibly outdated: confirm them against the official documentation for the installed version.
- Ask before actions that cost money, consume shared GPUs or cloud quota, touch personal or patient data, or cannot be undone.
Related skills
langchain: Framework for building LLM-powered applications with agents, chains, and RAG.crewai-multi-agent: Multi-agent orchestration framework for autonomous AI collaboration.evolving-ai-agents: Provides guidance for automatically evolving and optimizing AI agents across any domain using LLM-driven evolution algorithms.
Trigger Prompts & Evaluation Corpus
These evaluation prompts test that the agent correctly selects autogpt-agents for relevant tasks and leaves it out for near misses.
Should trigger (3)
- should trigger
“How do I set up AutoGPT locally with Docker?”
expects Explains the Docker-based install of the AutoGPT Platform and lists the access points: frontend at localhost:3000, backend API at localhost:8006/api, WebSocket at ws://localhost:8001/ws. Notes the PostgreSQL, Redis and RabbitMQ dependencies, and suggests checking the installed version's docs before running anything.
- should trigger
“I'm running the AutoGPT platform in Docker for my lab's literature-monitoring agent. I built a graph in the builder with a webhook block feeding an AITextGeneratorBlock and then an OUTPUT block, but when GitHub fires the webhook the execution just hangs in 'running' and never finishes. Services show as up. How do I debug this?”
expects Walks through diagnosing a stuck execution: check the execution status via REST polling or WebSocket updates, inspect the backend, RabbitMQ and Redis logs, and verify the credentials for the LLM provider are configured under Profile > Integrations. Also checks the webhook trigger and block links, consults the troubleshooting reference, and never invents commands or APIs.
- should trigger
“I want something that watches a set of preprint servers every morning, summarizes new papers that match my topics, and posts the summaries to our lab Discord without me touching anything. I'd like to build it by dragging boxes together instead of writing code. What are my options?”
expects Recommends a no-code visual agent builder with a scheduled trigger (AutoGPT Platform), using AI blocks for summarization and a Discord integration block. Describes the graph structure and credentials setup, asks about the preprint sources and topics, and mentions the cost and credits monitoring for LLM usage.
Near misses (2)
- near miss
“Write me a LangChain ReAct agent in Python with tool calling and a Chroma vector store so it can answer questions over my PDFs.”
expects Should go to the langchain skill: it provides code-level guidance for a ReAct agent with tools and vector store retrieval, not the AutoGPT visual builder.
- near miss
“I need a team of three role-based agents (researcher, writer, reviewer) that collaborate sequentially to draft a grant section. Which framework should I use and how do I define the roles?”
expects Should go to crewai-multi-agent, which covers role-based multi-agent collaboration with sequential or hierarchical process definitions, rather than AutoGPT's graph-based workflow builder.