AutoGPT

The platform has a Python backend (REST and websocket servers, graph executor, scheduler) backed by Postgres, Redis and RabbitMQ, and a Next.js frontend with the Agent Builder. An agent is a saved graph of blocks. Execution starts from input blocks or blocks without inbound links, queues each downstream block when its required inputs validate, and ends when nothing more can run; output blocks collect the results.

There are two multi-agent mechanisms. In graphs, a saved agent can be reused as an Agent block inside another agent, which gives fixed, hierarchical composition. In chat, AutoPilot can spawn child turns: delegate_to_expert runs a different expert with its own identity and memory, handoff_to_expert passes the thread to an expert, and run_sub_session starts a copy of the same identity with a clean context. Children report only to their parent (no sibling messages), inherit a narrowed tool set, and share one per-request budget: at most 3 hops deep, 8 agents per request, and a spend ceiling derived from the user's plan.

Memory follows identity rather than the request: each expert writes to its own memory namespace, while AutoPilot turns for one user share that user's memory and a user-wide file workspace. Sub-session copies are barred from writing memory. The collaboration doc notes that spend is counted after turns finish rather than reserved, so a wide fan-out can overshoot the ceiling.

Graphs can include a Human In The Loop block. When it runs, the node enters a review state and the run pauses until a person approves or rejects the data; if the block is marked editable the reviewer can change the data first, and an optional review message is passed on. Approved data leaves through approved_data and rejected data through rejected_data, so each decision can lead to a different path. The pricing page lists these approval gates for nested workflows as well. In chat, AutoPilot asks for missing inputs or credentials before it runs an agent. For delegated agents, questions go to the parent agent rather than to a person, and the collaboration doc says an automatic approval gate for agent actions is designed but not yet merged.

git clone https://github.com/Significant-Gravitas/AutoGPT.git

# Self-host from source (needs Git, Node.js/NPM, Docker and Docker Compose)
git clone https://github.com/Significant-Gravitas/AutoGPT.git
cd AutoGPT/autogpt_platform
cp .env.default .env          # add your model provider keys here
docker compose up -d --build
# Builder UI: http://localhost:3000. Save an agent whose Input block is named
# "question", then reuse it as an Agent block inside a second agent.

# Run a saved agent through the external API (key needs EXECUTE_GRAPH).
# Hosted base shown; a self-hosted backend serves the same /external-api routes.
curl -X POST "https://backend.agpt.co/external-api/v1/graphs/$GRAPH_ID/execute/1" \
  -H "X-API-Key: $AUTOGPT_API_KEY" -H "Content-Type: application/json" \
  -d '{"node_input": {"question": "Summarize this week in AI agents"}}'
# The reply holds an execution id; fetch output from
#   /external-api/v1/graphs/$GRAPH_ID/executions/<id>/results

• The single-container appliance installer is not live yet; use the manual from-source setup (Git, Node.js/NPM, Docker, Docker Compose). Windows users must use the manual path. The single-container mode is marked Experimental.
• Copy .env.default to .env before docker compose up; running the frontend outside Docker needs make init-env so DATABASE_URL and BETTER_AUTH_SECRET are set.
• Self-hosting means bringing your own model API keys; the hosted Platform includes model access.
• Installs from before the move off the bundled Supabase stack must refresh env files and move the database; the docs say the data migration routes have not been validated on a real old volume, so back up first.
• Default ports: UI 3000, REST 8006, websocket 8001.
• External API keys are scoped by permission (for example EXECUTE_GRAPH, WRITE_GRAPH).

Not any more. The repository now centres on the AutoGPT Platform (builder, AutoPilot, marketplace). The original standalone agent lives on as AutoGPT Classic in the classic/ folder under the MIT License.

Yes, as a client. The MCP Tool block calls tools on MCP servers over Streamable HTTP, and AutoPilot can connect MCP servers from chat. No option to expose AutoGPT itself as an MCP server was found.

Self-hosting has no license fee, but you supply infrastructure and model keys. The hosted Platform is paid (Pro at $50 per month after a 7-day trial, Max at $320 per month, Team on request), with workflow runs billed from a credit wallet.

Two ways: saved agents can be nested as Agent blocks inside other agents, and AutoPilot can delegate to expert agents or start sub-sessions, with limits of 3 hops and 8 agents per request.

A Claude Code block runs Claude Code in an E2B sandbox. A private preview described in the repository lets the Code Generation block and AutoPilot run through Codex App Server with a connected ChatGPT account.