How to Migrate from AutoGPT Classic to the AutoGPT Platform: A Complete Guide

Migrating from AutoGPT Classic to the AutoGPT Platform requires switching from a monolithic SQLite-based application to a containerized micro-service architecture, exporting your legacy data, and recreating custom logic using the Block SDK.

The AutoGPT Classic repository is no longer maintained and relies on a single-process Python architecture with SQLite persistence, while the new AutoGPT Platform provides a scalable, production-ready stack with FastAPI, Next.js, PostgreSQL, and RabbitMQ. This guide walks you through the complete migration process using the actual source files and commands from the Significant-Gravitas/AutoGPT repository.

Understanding the Architecture Changes

Before migrating, you must understand the fundamental differences between the deprecated Classic version and the new Platform.

AutoGPT Classic (Deprecated)

According to classic/README.md, AutoGPT Classic consists of a single monolithic Python script (cli.py) that manages agents using a local SQLite database (classic/agent.db). Configuration happens through environment variables and JSON files in classic/forge/config.json, with custom blocks stored in classic/forge/blocks/. This architecture does not receive security updates and cannot scale beyond a single process.

AutoGPT Platform (Current)

As implemented in autogpt_platform/, the new Platform separates concerns into distinct services: a FastAPI backend (backend/), a Next.js frontend (frontend/), PostgreSQL for persistence (managed by Prisma), Redis for caching, and RabbitMQ for message queuing. The Platform uses the Block SDK (backend/blocks/) for extensibility and provides a full CI/CD pipeline with automated testing.

Prerequisites and Environment Setup

Begin by cloning the unified repository that contains both Classic and Platform source code.

Clone the Repository and Configure Environment Variables

Navigate to the Platform directory and create your environment file from the default template:

git clone https://github.com/Significant-Gravitas/AutoGPT.git
cd AutoGPT/autogpt_platform
cp .env.default .env

Edit .env to migrate your API keys from Classic (such as OPENAI_API_KEY and ANTHROPIC_API_KEY), but remove obsolete variables like SQLITE_DB_PATH. The Platform reads all configuration from this .env file as documented in docs/platform/getting-started.md.

Step-by-Step Migration Process

The migration consists of three phases: infrastructure initialization, data export/import, and logic porting.

Export Data from AutoGPT Classic

From the repository root, dump the Classic SQLite database to SQL format:

sqlite3 classic/agent.db .dump > classic_dump.sql

This command exports the entire agent.db contents, including tables like memory and tasks. You may need to edit classic_dump.sql to rename tables or drop columns that conflict with the Platform's PostgreSQL schema defined in backend/prisma/schema.prisma.

Initialize the Platform Infrastructure

Start the core services and apply database migrations:

make start-core
make migrate

The make start-core command spins up Docker containers for PostgreSQL, Redis, and RabbitMQ, while make migrate executes Prisma migrations to create the required tables in the PostgreSQL database. These commands are defined in autogpt_platform/Makefile and documented in docs/platform/getting-started.md.

Transform and Import Legacy Data

Load your exported data into the Platform's PostgreSQL container:

docker exec -i $(docker ps -f name=postgres -q) psql -U postgres -d autogpt < classic_dump.sql

This pipes the SQL dump directly into the running Postgres instance. Verify the import by checking that persisted memories appear in the new database schema.

Recreate Custom Logic as Platform Blocks

Classic agents defined in classic/forge/config.json and custom blocks in classic/forge/blocks/*.py must be re-implemented using the Block SDK. Create a new block in backend/blocks/:

# backend/blocks/hello_world.py

from autogpt_libs.base import Block, BlockInput, BlockOutput

class HelloWorldInput(BlockInput):
    name: str

class HelloWorldOutput(BlockOutput):
    greeting: str

class HelloWorld(Block):
    """Return a friendly greeting."""
    input_schema = HelloWorldInput
    output_schema = HelloWorldOutput

    async def run(self, input: HelloWorldInput) -> HelloWorldOutput:
        return HelloWorldOutput(greeting=f"Hello, {input.name}!")

Register the block by adding it to backend/blocks/__init__.py. The Platform automatically discovers any subclass of Block and exposes it via the API.

Verifying Your Migration

Start the full stack to confirm everything works:

make run-backend
make run-frontend

The backend API serves at http://localhost:8001 and the Next.js frontend at http://localhost:3000. Open the UI, execute a test prompt, and verify that your migrated data appears correctly. Check the container logs to confirm RabbitMQ and Redis connections are healthy.

Summary

• AutoGPT Classic is deprecated and uses classic/agent.db (SQLite) with a single cli.py process.
• The Platform uses micro-services: FastAPI backend, Next.js frontend, PostgreSQL (Prisma), Redis, and RabbitMQ.
• Migration steps: Clone repo → Configure .env → Run make start-core and make migrate → Export SQLite with sqlite3 .dump → Import to Postgres via docker exec → Recreate blocks using the Block SDK.
• Custom logic from classic/forge/blocks/ moves to backend/blocks/ with classes inheriting from Block.
• Verification: Access http://localhost:3000 after running make run-backend and make run-frontend.

Frequently Asked Questions

Is AutoGPT Classic still maintained?

No. The classic/README.md explicitly states that Classic is no longer receiving security updates or new features. All development has moved to the AutoGPT Platform, which includes active maintenance, linting, formatting, and automated testing for every change.

Can I run Classic and Platform side-by-side?

Yes, temporarily. The Classic SQLite file (classic/agent.db) and the Platform's PostgreSQL database are independent. You can export data from a running Classic instance while testing the Platform, but you should migrate fully to the Platform to receive ongoing updates and security patches.

What happens to my custom blocks from Classic?

You must manually port them. Classic blocks in classic/forge/blocks/*.py follow a different interface than the Platform's Block SDK. Rewrite them as classes inheriting from Block in backend/blocks/, defining input_schema and output_schema using Pydantic models, and implement the run method as an async function.

Do I need to migrate my SQLite data or can I start fresh?

Starting fresh is valid and often simpler. If you have critical persisted memories or agent states in classic/agent.db, use the sqlite3 .dump export and PostgreSQL import method described above. If you lack critical data, skip the export/import steps and simply run make migrate to initialize an empty PostgreSQL schema.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}