Key Takeaways
- Repository: 187,453 stars, 582 open issues, not archived — actively pushed to as of this review
- AutoGPT Platform (autogpt_platform/, agpt.co): hosted, paid, visual agent builder — Polyform Shield License (source-available, restricts competing commercial use)
- Classic AutoGPT (classic/original_autogpt/): the original autonomous CLI agent — MIT license, still receives security and maintenance commits
- Local models: classic supports any OpenAI-API-compatible server (including Ollama) via OPENAI_API_BASE_URL, plus native Llamafile support via LLAMAFILE_API_BASE
- The Platform's own environment configuration has no Ollama or local-model settings — it is built around hosted model providers
- No affiliate program exists for AutoGPT on this site or anywhere; every link below is a plain, disclosed link
📍 In One Sentence
AutoGPT is now two products: a paid, hosted AutoGPT Platform (Polyform Shield license) that is where active development happens, and a legacy MIT-licensed classic CLI agent that still runs locally against Ollama through a generic OpenAI-compatible endpoint but receives maintenance updates rather than new features.
💬 In Plain Terms
The "AutoGPT" most people remember — a command-line agent you point at your own model — still exists and is still free (MIT), but the company behind it now spends its energy on a separate paid product with a visual builder. Read the license and the folder name before you decide which one you are evaluating.
📌Note: If a search result, tutorial, or old blog post talks about "AutoGPT" without specifying classic vs. Platform, assume it means the pre-2026 CLI agent — that is classic, and it is the only part of the project that is MIT and self-hostable for free.
What Is AutoGPT in 2026?
AutoGPT (github.com/Significant-Gravitas/AutoGPT) was the project that popularized the idea of an "autonomous agent" in 2023: give an LLM a goal, and let it plan, act, and self-critique in a loop without a human approving every step. In 2026, the same GitHub organization ships something structurally different: a commercial, hosted product called the AutoGPT Platform, with the original autonomous-loop agent kept alive as a secondary, MIT-licensed component.
- AutoGPT Platform (agpt.co / platform.agpt.co): the current flagship product, a hosted and paid visual agent builder
- AutoPilot: a chat-to-agent surface — describe a task in natural language and the Platform assembles an agent for it
- Agents dashboard: manage, monitor, and re-run agents you or the Marketplace have built
- Marketplace: browse and install pre-built agent templates from other users
- Build canvas: a drag-and-drop, node-based editor for building agents visually, similar in spirit to Langflow or Dify's workflow builders
- Self-hosting the Platform is technically possible (docker-compose.platform.yml, an installer/ script, and a single-container/ option exist in the repo), but the README's primary call-to-action is signing up for the hosted product, not self-hosting it
- classic/original_autogpt/: the original CLI-driven autonomous agent, now positioned as a legacy component alongside classic/forge (an agent-building framework), classic/benchmark, and classic/frontend
The MIT / Polyform License Split, Explained
AutoGPT's licensing is not a single answer, and getting it wrong matters if you plan to build on the code commercially. The repository uses two different licenses for two different parts of the codebase.
classic/ (original_autogpt, forge, benchmark, frontend): MIT License
Everything under the classic/ folder — the original autonomous CLI agent, the forge agent-building framework, the benchmark suite, and the classic frontend — is MIT licensed. MIT is a permissive license: you can run it, modify it, fork it, and build a commercial product on top of it without any obligation to release your changes or pay anyone.
autogpt_platform/ (the current flagship product): Polyform Shield License
Everything under autogpt_platform/ — the code behind the hosted AutoGPT Platform, including AutoPilot, the Agents dashboard, the Marketplace, and the Build canvas — is released under the Polyform Shield License. This is a source-available license, not an OSI-approved open-source license. You can read the code and self-host it for your own use, but Polyform Shield specifically restricts using the software to build a competing commercial offering. That is a meaningfully different deal than MIT: "you can see the code" is not the same as "you can build a business on the code."
Is Classic AutoGPT Still Maintained?
Yes, in the sense that matters for security and stability, but not in the sense of new capabilities. The classic/ folder continues to receive commits from the core team — recent examples include a dependency-vulnerability cleanup, an SSRF-hardening fix for outbound request handling, and a version cap applied after a compromised release of a dependency the classic agent relies on. Those are exactly the commits you want to see on code you plan to run: they are defensive, not decorative.
What classic does not get is new feature work. The commits that add new capabilities — new agent-building primitives, marketplace features, new AutoPilot behavior — land in autogpt_platform/. The project's own README, issue labels, and folder structure treat classic as a legacy, secondary track that is kept functional and secure rather than actively extended. That is a meaningfully different situation from "abandoned": commits keep classic running and safe, but the team's product energy is elsewhere.
Repository status
- What it shows:
- Not archived; pushed same day as this review; 582 open issues
classic/ commit pattern
- What it shows:
- Security fixes and dependency caps land regularly; no major new-feature commits
Where new features land
- What it shows:
- autogpt_platform/ — AutoPilot, Marketplace, and Build canvas get the active development
Project framing
- What it shows:
- README and primary CTA promote the hosted Platform; classic is positioned as the legacy CLI track
📌Note: We did not run our own test suite against classic AutoGPT for this review — the verdict below is based on documented commit history and issue activity on the classic/ subfolder specifically, not on measured benchmark numbers we generated ourselves. Verify current status against the repository before committing significant time to it.
How to Run Classic AutoGPT Locally with Ollama
Classic AutoGPT does not have a named, first-class "Ollama integration." It has a generic OpenAI-API-compatible client, configured through classic/original_autogpt/.env.template, and Ollama happens to expose an OpenAI-compatible endpoint — so pointing one at the other is a configuration step, not a built-in feature.
- 1Clone github.com/Significant-Gravitas/AutoGPT and open the classic/original_autogpt/ folder — this is the MIT-licensed CLI agent, not the autogpt_platform/ folder.
- 2Install Ollama separately and pull a model capable of following multi-step tool-calling instructions; the site's own local coding-model and tool-calling comparisons are a reasonable starting point for picking one.
- 3Copy .env.template to .env inside classic/original_autogpt/.
- 4Set OPENAI_API_BASE_URL in .env to your Ollama server's OpenAI-compatible endpoint (Ollama exposes this at /v1 on its default port). Ollama does not check the API key value, but the client still requires the OPENAI_API_KEY field to be set to a non-empty placeholder string.
- 5Alternatively, if you are running a Llamafile instead of Ollama, set LLAMAFILE_API_BASE instead — this is a separate, natively supported local-inference path, not routed through the generic OpenAI-compatible setting.
- 6Install classic's Python dependencies per the instructions in classic/original_autogpt/README.md and run the agent from that folder, not from the repository root.
- 7Expect to supervise it closely on the first runs. Because this is the generic OpenAI-compatible mechanism rather than a maintained, tested Ollama integration, model-specific quirks (tool-call formatting, context-length limits) are yours to debug.
Does classic AutoGPT need a specific Ollama version?
The project does not document a pinned, tested Ollama version for classic — because the integration is the generic OPENAI_API_BASE_URL mechanism, compatibility depends on your Ollama version exposing a stable OpenAI-compatible /v1 endpoint, which recent Ollama releases do. Check Ollama's own release notes for API compatibility, not AutoGPT's.
Can I run classic AutoGPT fully offline?
Yes, once OPENAI_API_BASE_URL points at a local Ollama or Llamafile endpoint, classic AutoGPT does not need outbound API calls to a cloud provider. It may still make outbound web requests as part of an agent's task (e.g., browsing tools) unless you disable that capability.
Realistic Expectations for the Planning Loop
Classic AutoGPT's core mechanic — an LLM planning its own next step in a loop, deciding when the task is done, without a human approving each action — is the same architecture that made it famous and the same architecture that has aged the least well against local, often smaller, open-weight models.
- Autonomous, unscoped planning loops ask more of the underlying model than scoped, tool-limited agents do: the model must track long-horizon state, decide when to stop, and self-correct without a human catching drift early
- Smaller local models (the kind most people run comfortably on consumer hardware via Ollama) are more prone to losing the thread over long autonomous runs than large hosted models, simply because planning and self-correction over many steps is a harder capability than single-turn tool use
- This is a comparative, architectural point, not a claim about any specific model or version: an unscoped planning loop is a harder problem for a local model to sustain than a scoped harness where a human approves each step
- Scoped alternatives — Cline + Ollama, Continue.dev's Agent mode, and graph-based orchestrators like LangGraph — constrain the agent to one editor, one file set, or one explicit approval gate per action, which reduces how far a single planning mistake can drift before a human notices
Who Should Use Classic AutoGPT vs. the Platform?
The right choice depends on whether you want a free, self-hosted, hands-on experiment or a paid, managed product.
Use classic AutoGPT (local, MIT) if
- You want to experiment with the original autonomous-agent architecture for free, on your own hardware, against a local model via Ollama
- You are comfortable debugging Python dependencies, prompt-format quirks, and a codebase that receives security fixes but not new features
- You specifically want an MIT-licensed codebase you can modify and redistribute without restriction, including in a commercial product
- You are prototyping or learning how planning-loop agents work, rather than depending on one for production output
Use the AutoGPT Platform (hosted, Polyform) if
- You want a managed, actively developed product with a visual builder, a Marketplace of pre-built agents, and a chat-to-agent AutoPilot
- You are fine paying for hosting and do not need to modify the underlying source for a competing commercial offering
- You need the features under active development — new AutoPilot behavior, Marketplace agents, Build-canvas capabilities — that are not backported to classic
Consider a different tool entirely if
- You need a reliable, supervised local coding agent today — Cline + Ollama or Continue.dev's Agent mode are more actively maintained for that specific job and scope the agent to reduce drift
- You need a self-hosted, permissively licensed, actively developed visual agent-orchestration tool — Langflow or Dify (both reviewed on this site) are closer to what the AutoGPT Platform offers, without the Polyform restriction
AutoGPT vs. Alternatives
AutoGPT's two halves compete with different tools: classic AutoGPT competes with other local, scoped agent harnesses; the Platform competes with other hosted or self-hostable visual agent builders.
Tool | Model | License | Best For | Maintenance |
|---|---|---|---|---|
| AutoGPT (classic) | Local via Ollama (OpenAI-compatible URL) | MIT | Autonomous-loop experiments | Security fixes only |
| AutoGPT Platform | Hosted providers | Polyform Shield | Visual builder + Marketplace | Active |
| Cline + Ollama | Local | Apache 2.0 | Supervised coding agent | Active |
| Continue.dev Agent | Local or cloud | Apache 2.0 | IDE-scoped agent mode | Active |
| LangGraph | Local or cloud | MIT | Custom graph-based agents | Active |
Common Mistakes When Evaluating AutoGPT
Most confusion about AutoGPT in 2026 comes from not knowing which half of the project a claim refers to.
Mistake 1: Calling the whole project "MIT licensed"
MIT covers classic/ only. The Platform — the product actually promoted on the project's homepage — is Polyform Shield licensed, a source-available license that restricts competing commercial use. Check the LICENSE file in the specific folder you plan to use before assuming MIT applies.
Mistake 2: Assuming the Platform supports Ollama the way classic does
The Platform's environment configuration has no Ollama or local-model settings — it is built around hosted model providers. If local inference is the point, you want classic/original_autogpt/, not the Platform.
Mistake 3: Reading "AutoGPT is unmaintained" as true for the whole repository
The repository as a whole is very actively pushed to — the activity is just concentrated in autogpt_platform/. Classic still gets security and maintenance commits; it is accurate to call it secondary and feature-frozen, not accurate to call the project abandoned.
Mistake 4: Expecting a tested, maintained Ollama integration
Classic's local-model support is the generic OPENAI_API_BASE_URL mechanism, not a purpose-built, documented Ollama integration. It works, but model-specific formatting and tool-calling quirks are not something the AutoGPT team tests or supports directly.
Frequently Asked Questions
Is AutoGPT MIT licensed?
Partly. The classic/ folder (original_autogpt, forge, benchmark, frontend) is MIT licensed. The autogpt_platform/ folder — the current flagship, hosted AutoGPT Platform — is licensed under Polyform Shield, a source-available license, not a permissive open-source one.
Is AutoGPT still maintained?
Yes. The repository is not archived and was pushed to the same day as this review, with 582 open issues. Active feature development is concentrated in autogpt_platform/; the classic/ folder still receives security and maintenance commits but not new features.
Does AutoGPT work with Ollama?
The classic CLI agent does, through its generic OpenAI-API-compatible client — set OPENAI_API_BASE_URL to your Ollama server's /v1 endpoint. This is not a named, purpose-built "Ollama integration," and it is not supported by the current AutoGPT Platform, whose configuration has no local-model settings.
What is the AutoGPT Platform?
The AutoGPT Platform (agpt.co) is the project's current commercial product: a hosted, paid, visual agent builder with a chat-to-agent AutoPilot, an Agents dashboard, a Marketplace of pre-built agents, and a node-based Build canvas. It can technically be self-hosted, but the primary path promoted by the project is the hosted signup.
Is AutoGPT free to use?
Classic AutoGPT (MIT) is free to self-host. The AutoGPT Platform is a paid, hosted product; self-hosting it is possible under the Polyform Shield license, which permits personal or internal use but restricts building a competing commercial offering on top of it.
What is the difference between AutoGPT and the AutoGPT Platform?
AutoGPT (classic) is the original 2023-era autonomous CLI agent — MIT licensed, runs locally, receives maintenance commits. The AutoGPT Platform is a separate, newer, commercial product from the same organization — a hosted visual agent builder under a source-available license, where active development now happens.
Can I still use AutoGPT for free local experimentation?
Yes, via classic/original_autogpt/, which remains MIT licensed and runs against a local Ollama server through the OPENAI_API_BASE_URL setting. Expect a maintenance-mode codebase, not a feature-actively-developed one.
Why did AutoGPT split into two licenses?
The project's commercial focus moved to the hosted AutoGPT Platform. Polyform Shield lets the company keep that code source-available — readable and self-hostable for personal use — while preventing a competitor from taking the code and reselling a rebranded version, something a permissive license like MIT would not have prevented.
Is classic AutoGPT better than Cline or Continue.dev for local agent work?
Not for unattended local automation. Classic AutoGPT's unscoped, autonomous planning loop asks more of the underlying model than scoped, single-editor harnesses like Cline + Ollama or Continue.dev's Agent mode, which limit the blast radius of a planning mistake with per-step approval. Classic AutoGPT is better suited to experimenting with the planning-loop architecture itself than to production coding work.