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

> Easily migrate from AutoGPT Classic to the AutoGPT Platform. Learn how to export data and recreate logic with the Block SDK in this comprehensive guide.

- Repository: [AutoGPT/AutoGPT](https://github.com/Significant-Gravitas/AutoGPT)
- Tags: migration-guide
- Published: 2026-02-24

---

**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`](https://github.com/Significant-Gravitas/AutoGPT/blob/main/classic/README.md), AutoGPT Classic consists of a single monolithic Python script ([`cli.py`](https://github.com/Significant-Gravitas/AutoGPT/blob/main/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`](https://github.com/Significant-Gravitas/AutoGPT/blob/main/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:

```bash
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`](https://github.com/Significant-Gravitas/AutoGPT/blob/main/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:

```bash
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`](https://github.com/Significant-Gravitas/AutoGPT/blob/main/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:

```bash
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`](https://github.com/Significant-Gravitas/AutoGPT/blob/main/docs/platform/getting-started.md).

### Transform and Import Legacy Data

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

```bash
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`](https://github.com/Significant-Gravitas/AutoGPT/blob/main/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/`:

```python

# 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`](https://github.com/Significant-Gravitas/AutoGPT/blob/main/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:

```bash
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`](https://github.com/Significant-Gravitas/AutoGPT/blob/main/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`](https://github.com/Significant-Gravitas/AutoGPT/blob/main/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.