docs: improve AutoPilot vs Builder comparison

Fix framing that positioned AutoPilot as limited to quick/one-off tasks.
Add "Who is it for" row clarifying AutoPilot is for everyone while the
Builder targets technical users comfortable with visual programming.

Resolves SECRT-1862

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

docs/platform/SUMMARY.md

@@ -2,20 +2,34 @@
 
 * [What is the AutoGPT Platform?](what-is-autogpt-platform.md)
 
-## Getting Started
+## Using the Platform
 
-* [Setting Up Auto-GPT (Local Host)](getting-started.md)
+* [Getting Started (Cloud)](getting-started-cloud.md)
+* [AutoPilot](autopilot.md)
+* [Agent Builder Guide](agent-builder-guide.md)
+* [Agent Library](agent-library.md)
+* [Marketplace](marketplace.md)
+* [Scheduling & Triggers](scheduling-and-triggers.md)
+* [Templates](templates.md)
+* [Credits & Billing](credits-and-billing.md)
+* [Integrations & Credentials](integrations-and-credentials.md)
+* [Data Flow & Execution](data-flow-and-execution.md)
+* [Sharing & Exporting Agents](sharing-and-exporting.md)
+
+## Self-Hosting
+
+* [Setting Up AutoGPT (Self-Host)](getting-started.md)
 * [AutoGPT Platform Installer](installer.md)
+* [Advanced Setup](advanced_setup.md)
+
+## Tutorials
+
+* [Create a Basic Agent](create-basic-agent.md)
 * [Edit an Agent](edit-agent.md)
 * [Delete an Agent](delete-agent.md)
 * [Download & Import an Agent](download-agent-from-marketplace-local.md)
-* [Create a Basic Agent](create-basic-agent.md)
 * [Submit an Agent to the Marketplace](submit-agent-to-marketplace.md)
 
-## Advanced Setup
-
-* [Advanced Setup](advanced_setup.md)
-
 ## Building Blocks
 
 * [Agent Blocks Overview](agent-blocks.md)

docs/platform/agent-builder-guide.md

@@ -0,0 +1,105 @@
+# Agent Builder Guide
+
+## Overview
+
+The Agent Builder is the visual editor where you design and build agents by connecting blocks together on a canvas. Each block is a single action — like generating text, calling an API, or processing data — and you wire them together to create automated workflows.
+
+**URL:** [platform.agpt.co/build](https://platform.agpt.co/build)
+
+## The Builder Interface
+
+When you open the builder, you'll see:
+
+- **Canvas**: The main workspace where you place and connect blocks
+- **Blocks Menu**: A panel on the left-hand side where you browse and search for blocks
+- **Save Button**: Save your agent with a title and description
+
+## Working with Blocks
+
+### Types of Blocks
+
+Blocks fall into three categories:
+
+| Type | Description |
+|------|-------------|
+| **Input Blocks** | Define what information the agent needs when it runs. These become the input fields users fill in when starting a task. Types include text inputs, file inputs, and more. |
+| **Action Blocks** | Perform operations — AI text generation, image creation, API calls, data processing, and hundreds of integrations with external platforms. |
+| **Output Blocks** | Define what the agent returns as its result. These become the visible output when a task completes. |
+
+Input and output blocks define the **schema** of your agent — they determine what users see when running the agent. All other blocks inside the agent are internal and not exposed to the user at runtime.
+
+{% hint style="info" %}
+There is also a special type of input block: **Trigger Blocks**. These allow your agent to be activated by external events via webhooks rather than manual input. See [Scheduling & Triggers](scheduling-and-triggers.md) for details.
+{% endhint %}
+
+### Adding Blocks
+
+1. Open the **Blocks menu** on the left-hand side of the builder
+2. Browse categories or use the search bar to find a specific block
+3. Click on a block to add it to the canvas
+
+There are hundreds of blocks available, integrating with many platforms and services.
+
+### Connecting Blocks
+
+Blocks have **input pins** and **output pins**. Pins are typed — they handle specific data types like text, numbers, files, and more.
+
+To connect blocks:
+
+1. Click on an **output pin** of one block
+2. Drag to an **input pin** of another block (or simply click the output pin, then click the input pin)
+3. A **connection line** will appear between the two pins
+
+When the agent runs, data flows along these connections. This is visually represented by a **coloured bead** that slides along the connection line from the output pin to the input pin.
+
+### Configuring Blocks
+
+Many blocks have settings you can configure directly on the block. For example:
+
+- The **AI Text Generator** block lets you choose which language model to use
+- **Integration blocks** may require credentials (see [Integrations & Credentials](integrations-and-credentials.md))
+- Some blocks allow you to hardcode values on their input pins instead of connecting them to other blocks
+
+If a block requires a credential you haven't connected yet, a **credential bar** will appear prompting you to add it (via OAuth, API key, or username/password depending on the service).
+
+## Saving Your Agent
+
+To save your agent:
+
+- Press **Ctrl+S**, or
+- Click the **Save button** in the builder
+
+When saving, you can provide a **title** and **description** for the agent. This is a local save to your personal library. For publishing to the public marketplace, see [Publishing to the Marketplace](marketplace.md#publishing-an-agent).
+
+{% hint style="info" %}
+There is currently no draft vs. saved state — saving an agent immediately updates it in your library.
+{% endhint %}
+
+## Navigating Back to Your Library
+
+After saving, click the **Agents** button in the navigation bar to return to your library and find your agent.
+
+## Editing an Existing Agent
+
+To open an existing agent in the builder:
+
+1. Go to your **Agent Library** (click **Agents** in the nav bar)
+2. Click on the agent you want to edit
+3. Click the **three dots** menu (⋯) on the far right-hand side of the screen
+4. Select **Edit Agent**
+
+This will open the agent in the builder with all its existing blocks and connections.
+
+## Error Handling
+
+When a block fails during execution, it produces data on its **error pin**. As the agent creator, you decide how to handle errors:
+
+- **Surface the error**: Connect the error pin to an output block so the error is returned as the agent's result
+- **Handle gracefully**: Connect the error pin to other blocks that provide fallback behaviour, ensuring the agent continues working even when individual blocks encounter problems
+
+## Tips
+
+- **Name your input and output blocks clearly** — these names become the labels users see when running your agent
+- **Test incrementally** — save and run your agent frequently as you build to catch issues early
+- **Use the search** in the blocks menu to quickly find what you need among hundreds of available blocks
+- **Check the pin types** — connections only work between compatible pin types

docs/platform/agent-library.md

@@ -0,0 +1,93 @@
+# Agent Library
+
+## Overview
+
+The Agent Library is your personal collection of agents. From here you can run agents, view task history, set up schedules and triggers, edit agents, and manage your collection.
+
+**URL:** [platform.agpt.co/library](https://platform.agpt.co/library)
+
+**Access:** Click the **Agents** button in the navigation bar.
+
+## Library View
+
+Your library displays all of your agents, including agents you've built yourself and agents you've added from the marketplace. Each agent shows its name and key information at a glance.
+
+### Favouriting Agents
+
+To keep important agents easy to find, click the **heart icon** on any agent to favourite it. Favourited agents are pinned to the top of your library.
+
+{% hint style="info" %}
+There is currently no folder system for organising agents. Use favourites to pin your most-used agents to the top.
+{% endhint %}
+
+## Agent Detail View
+
+Click on any agent to open its detail view. This screen provides:
+
+- **Tasks**: A full history of every time this agent has been executed
+- **Scheduled**: A list of active schedules for this agent
+- **Templates**: Saved input configurations for quick re-runs
+
+These are accessible via tabs on the left-hand side of the agent screen (e.g., `Tasks 286 | Scheduled 1 | Templates 0`).
+
+### Agent Actions Menu
+
+Click the **three dots** (⋯) on the far right-hand side of the agent screen to access:
+
+| Action | Description |
+|--------|-------------|
+| **Edit Agent** | Opens the agent in the builder for editing |
+| **Delete Agent** | Permanently removes the agent from your library |
+| **Export Agent to File** | Downloads the agent as a file you can share with others |
+
+## Running an Agent
+
+To run an agent manually:
+
+1. Open the agent from your library
+2. Click **New Task**
+3. Fill in the required input fields
+4. Click **Start Task**
+
+The task will begin executing immediately. You can watch the progress and view the results once it completes.
+
+{% hint style="warning" %}
+If the agent uses **trigger blocks** instead of standard input blocks, the **New Task** button is replaced with **New Trigger**. See [Scheduling & Triggers](scheduling-and-triggers.md) for details.
+{% endhint %}
+
+## Viewing Task Results
+
+Every time an agent runs, it creates a **task**. To view task results:
+
+1. Open the agent from your library
+2. In the left-hand pane, browse the list of completed tasks
+3. Click on a task to view its details
+
+A task detail view shows:
+
+- **Inputs**: The values that were provided when the task started
+- **Outputs**: The results the agent produced
+- **Cost**: The total credit cost for this task execution, displayed at the top of the task
+
+You can also **share a task** by copying its URL, which allows others to view the task output directly.
+
+## Uploading an Agent
+
+To import an agent from a file:
+
+1. Go to your Agent Library
+2. Click **Upload Agent** at the top
+3. Select the agent file from your computer
+
+The agent will be added to your library and can be run or edited like any other agent. This is useful for importing agents shared by other users outside of the marketplace.
+
+## Deleting an Agent
+
+1. Open the agent from your library
+2. Click the **three dots** (⋯) on the far right
+3. Select **Delete Agent**
+4. Confirm the deletion when prompted
+
+{% hint style="danger" %}
+Deleting an agent is permanent and cannot be undone. Make sure you want to remove it before confirming.
+{% endhint %}

docs/platform/autopilot.md

@@ -0,0 +1,62 @@
+# AutoPilot
+
+## Overview
+
+AutoPilot is your AI assistant built directly into the AutoGPT Platform. It can perform virtually any action on the platform through natural conversation — from running agents to generating images, conducting research, and even building entire agents for you.
+
+## Accessing AutoPilot
+
+AutoPilot is always available by clicking the **Home** button in the top-left of the navigation bar, or by navigating directly to [platform.agpt.co](https://platform.agpt.co).
+
+## What AutoPilot Can Do
+
+AutoPilot has access to the full power of the platform. Here's what it can help you with:
+
+### Run Agents
+
+Ask AutoPilot to run any agent in your library. It will handle filling in the inputs and executing the task for you.
+
+### Build Agents
+
+Describe the workflow you want and AutoPilot will create an agent for you in the builder. You can also ask it to edit your existing agents or modify agents you've added from the marketplace.
+
+### Browse the Marketplace
+
+Ask AutoPilot to find agents for a specific use case and it will search the marketplace for you.
+
+### Execute Blocks Directly
+
+AutoPilot can run individual blocks without building a full agent, giving it direct access to around **400 tools and counting**. This means you can:
+
+- **Conduct research** with Perplexity
+- **Generate images** with the latest image models
+- **Edit pictures** using AI image editing blocks
+- **Generate videos** using video generation blocks
+- **Run any model** on inference services like Replicate
+- **Make custom HTTP requests** to any API
+- **Write and execute code**, including delegating coding tasks to Claude Code
+
+### Manage Your Library
+
+AutoPilot can help you manage your agent library, view task results, set up schedules, and more.
+
+## Tips for Using AutoPilot
+
+- **Be specific**: The more detail you provide, the better AutoPilot can assist you. Instead of "make me an agent", try "build me an agent that takes a blog topic as input, generates an outline with Claude, then writes the full article".
+- **Iterate**: You can refine results by asking follow-up questions or requesting changes.
+- **Explore capabilities**: If you're unsure whether AutoPilot can do something, just ask — it has access to a vast number of tools through the platform's block system.
+
+## AutoPilot vs. the Agent Builder
+
+AutoPilot and the Agent Builder are two ways to achieve the same things on the platform. AutoPilot can do anything the builder can — including creating and editing full, reusable agents — and it can also run blocks directly without building an agent first.
+
+| | AutoPilot | Agent Builder |
+|---|-----------|---------------|
+| **Who is it for** | Everyone — no technical knowledge required | Technical users with a grasp of visual programming |
+| **Best for** | Natural language interaction, doing things fast, and accessing blocks directly | Hands-on visual control over exactly how an agent is wired together |
+| **How it works** | Conversational — describe what you want | Visual — drag, drop, and connect blocks on a canvas |
+| **Can build agents** | Yes — describe what you want and it builds the agent for you | Yes — you build the agent manually |
+| **Can edit agents** | Yes — including agents from the marketplace | Yes — full visual editing |
+| **Block access** | Can run any block directly without building an agent | Blocks must be connected into an agent workflow |
+
+Choose whichever approach suits you. Many users use both — AutoPilot for speed, and the builder when they want fine-grained visual control over their workflow.

docs/platform/credits-and-billing.md

@@ -0,0 +1,55 @@
+# Credits & Billing
+
+## Overview
+
+The AutoGPT Platform uses a credit system to manage usage. Credits are consumed when blocks execute during agent runs. This guide explains how credits work, how pricing is determined, and how to monitor your spending.
+
+{% hint style="info" %}
+The platform is currently in a **pre-release closed beta**. Pricing is subject to change.
+{% endhint %}
+
+## How Credits Work
+
+Credits are consumed on a **per-block-run** basis. Each time a block executes during an agent run, it costs a certain number of credits. The price of a block covers its compute, development, and operational costs — there are no separate charges for infrastructure or API usage.
+
+### Block Pricing
+
+Block prices vary depending on the block:
+
+- **Fixed-price blocks**: Some blocks have a flat price regardless of how they are configured (e.g., basic data processing blocks)
+- **Variable-price blocks**: Some blocks have a price that changes based on the settings you choose. For example, the **AI Text Generator** block's price changes depending on which large language model you select
+
+{% hint style="info" %}
+The current pricing system charges a flat rate per model for AI blocks — you are **not** charged per token.
+{% endhint %}
+
+Users are not charged for anything else on the platform beyond block execution. There are no subscription fees, storage fees, or platform access fees.
+
+## Checking Your Balance
+
+Your credit balance is displayed in the **top-right corner** of the screen at all times, visible from any page on the platform.
+
+## Viewing Task Costs
+
+To see how many credits a specific agent run consumed:
+
+1. Go to your [Agent Library](agent-library.md)
+2. Open the agent
+3. Click on a completed task in the left-hand pane
+4. The **total credit cost** for that task is displayed at the top of the task detail view
+
+{% hint style="info" %}
+There is no centralised ledger for browsing all credit spend across your account. Credit costs are available on a per-task basis within each agent.
+{% endhint %}
+
+## Running Out of Credits
+
+There are no hard limits on usage beyond your credit balance. If your credit balance reaches zero:
+
+- **Running agents will stop executing**
+- **Scheduled agents will not run** until credits are replenished
+- You will need to add more credits to continue using the platform
+
+## Adding Credits
+
+Credits can be added through the platform. Navigate to your profile settings to manage your credit balance.

docs/platform/data-flow-and-execution.md

@@ -0,0 +1,84 @@
+# Data Flow & Execution
+
+## Overview
+
+Understanding how agents execute is key to building effective workflows. This guide explains how data flows through an agent, what determines execution order, and how to work with lists and errors.
+
+## Execution Order
+
+Agent execution is entirely **determined by data flow**. There is no separate execution flow or ordering mechanism — data dependencies are the only thing that controls which block runs when.
+
+### How It Works
+
+1. **Execution starts from input blocks**, which yield their data when the agent is triggered (either manually or via a trigger/schedule)
+2. The next block to run is whichever block has **all of its connected inputs satisfied**
+3. This continues block by block, following the data flow, until all blocks have executed or an unhandled error occurs
+4. **Output blocks** collect the final results and present them to the user
+
+### Required Inputs
+
+A block will only execute when:
+
+- All **connected input pins** have received data from their upstream blocks
+- All **required input pins** have values — either from a connection or from a hardcoded value set directly on the block
+
+This means you can have blocks that don't depend on each other execute in any order, while blocks that depend on the output of another block will always wait.
+
+## Working with Pins
+
+### Pin Types
+
+Input and output pins are typed. Common types include:
+
+- **Text**: String values
+- **Number**: Numeric values
+- **File**: File uploads or downloads
+- **List**: Arrays of items
+- **Boolean**: True/false values
+- **Object**: Structured data
+
+Connections can only be made between compatible pin types.
+
+### Data Flow Visualisation
+
+When an agent is running, you can see data moving through the workflow in real time. Data flow is represented by a **coloured bead** that slides along each connection line from the output pin to the input pin, giving you a clear visual of what's happening.
+
+## Working with Lists
+
+Blocks can handle list data in flexible ways:
+
+- **Outputting lists**: Some blocks produce a list of items as their output. You can choose to receive the full list as a single output or receive individual items one at a time.
+- **Iterating over lists**: You can send a list into a block that iterates through its contents, yielding each item one by one. This is useful for processing each item in a list independently.
+
+This makes it straightforward to build agents that process batches of data — for example, fetching a list of URLs and then processing each one through an AI block.
+
+## Error Handling
+
+When a block fails during execution, it does **not** automatically stop the entire agent. Instead:
+
+1. The failed block produces data on its **error pin**
+2. What happens next depends on how you've wired the agent
+
+### Handling Errors Gracefully
+
+You have full control over error handling through the block connections:
+
+- **Surface the error**: Connect the error pin to an output block to return the error as part of the agent's result. This is useful for debugging or when you want users to see what went wrong.
+- **Handle and continue**: Connect the error pin to other blocks that provide fallback behaviour. For example, retry with different settings, use a default value, or route to an alternative workflow path.
+- **Ignore the error**: If the error pin is not connected, the error data is simply not propagated. Downstream blocks that depend on the failed block's normal output pins will not execute (since their inputs won't be satisfied).
+
+{% hint style="info" %}
+Building robust agents means thinking about what happens when things go wrong. Consider connecting error pins to output blocks during development so you can see any issues, then add proper error handling once your agent is working.
+{% endhint %}
+
+## Execution Summary
+
+| Concept | How It Works |
+|---------|-------------|
+| **Execution order** | Determined entirely by data flow — blocks run when all inputs are ready |
+| **Starting point** | Input blocks yield data first |
+| **Ending point** | Output blocks collect final results |
+| **Parallel execution** | Blocks with no dependencies on each other can execute in any order |
+| **Error handling** | Failed blocks yield data on their error pin — you decide what to do with it |
+| **Lists** | Can be processed as a whole or iterated item by item |
+| **Visual feedback** | Coloured beads slide along connection lines during execution |

docs/platform/getting-started-cloud.md

@@ -0,0 +1,79 @@
+# Getting Started with AutoGPT (Cloud)
+
+## Introduction
+
+This guide will get you up and running on the hosted AutoGPT Platform at [platform.agpt.co](https://platform.agpt.co). No installation, Docker, or API keys required — just sign up and start building.
+
+{% hint style="info" %}
+Looking to self-host instead? See the [Self-Hosting Guide](getting-started.md).
+{% endhint %}
+
+## Creating Your Account
+
+1. Navigate to [platform.agpt.co](https://platform.agpt.co)
+2. Click **Sign Up** and create your account
+3. Once signed in, you'll land on the **AutoPilot** home screen
+
+That's it — you're ready to go. The cloud platform comes with built-in credits and pre-configured API keys for services like OpenAI and Replicate, so you can start using AI blocks immediately without providing your own keys.
+
+## Platform Navigation
+
+The AutoGPT Platform has four main areas, accessible from the navigation bar at the top of every screen:
+
+| Nav Button | URL | Description |
+|------------|-----|-------------|
+| **Home** | [platform.agpt.co](https://platform.agpt.co) | AutoPilot — your AI assistant for the platform |
+| **Build** | [platform.agpt.co/build](https://platform.agpt.co/build) | Agent Builder — visual editor for creating agents |
+| **Agents** | [platform.agpt.co/library](https://platform.agpt.co/library) | Your Agent Library — all your saved agents |
+| **Marketplace** | [platform.agpt.co/marketplace](https://platform.agpt.co/marketplace) | Community marketplace for discovering agents |
+
+Your **credit balance** is displayed in the top-right corner of the screen at all times. Your **profile menu** (top-right avatar) gives you access to account settings, integrations, and agent publishing.
+
+## What to Do First
+
+Here are three great ways to get started:
+
+### Option 1: Chat with AutoPilot
+
+Click **Home** in the nav bar to open AutoPilot. You can ask it to do almost anything on the platform — browse the marketplace, run agents, build agents, generate images, conduct research, and more. It's the fastest way to experience the platform.
+
+### Option 2: Add an Agent from the Marketplace
+
+1. Click **Marketplace** in the nav bar
+2. Browse or search for an agent that interests you
+3. Click on an agent to view its details
+4. Click **Add to Library**
+5. Navigate to **Agents** to find it in your library
+6. Click on the agent and press **New Task** to run it
+
+### Option 3: Build Your Own Agent
+
+1. Click **Build** in the nav bar to open the Agent Builder
+2. Open the Blocks menu on the left-hand side
+3. Add an **Input Block**, an **AI Text Generator Block**, and an **Output Block**
+4. Connect them together by dragging between their pins
+5. Press **Ctrl+S** or click the save button to save your agent
+6. Navigate to **Agents** to find and run it
+
+For a detailed walkthrough, see [Creating a Basic Agent](create-basic-agent.md).
+
+## Key Concepts
+
+Before diving deeper, here are the core concepts you'll encounter:
+
+- **Agent**: An automated workflow you design to perform specific tasks. Agents are made up of connected blocks.
+- **Block**: A single action within an agent — such as generating text with AI, sending an email, or looking up data. There are hundreds of blocks integrating with many platforms.
+- **Task**: A single execution of an agent. When you run an agent with a set of inputs, that creates a task. You can view the task's inputs, outputs, and credit cost.
+- **AutoPilot**: Your AI assistant that can perform any action on the platform through natural conversation.
+- **Marketplace**: A public library of community-built agents you can add to your own library.
+- **Credits**: The currency used to run blocks. Each block has its own price. Your balance is shown in the top-right corner.
+
+## Next Steps
+
+| Guide | Description |
+|-------|-------------|
+| [AutoPilot](autopilot.md) | Learn what AutoPilot can do for you |
+| [Agent Builder Guide](agent-builder-guide.md) | Master the visual agent builder |
+| [Agent Library](agent-library.md) | Manage your agents, tasks, and schedules |
+| [Marketplace](marketplace.md) | Discover and share agents |
+| [Credits & Billing](credits-and-billing.md) | Understand the credit system |

docs/platform/integrations-and-credentials.md

@@ -0,0 +1,67 @@
+# Integrations & Credentials
+
+## Overview
+
+Many blocks on the AutoGPT Platform integrate with external services like Google, GitHub, Linear, Twitter, and more. These integrations require credentials — such as OAuth connections, API keys, or username/password pairs — to access your accounts on those services.
+
+This guide explains how credentials work on the platform, how to add them, and how to manage them.
+
+## How Credentials Work
+
+### Platform-Provided Credentials
+
+On the cloud-hosted platform at [platform.agpt.co](https://platform.agpt.co), many credentials are **provided by default**. Services like OpenAI, Anthropic, and Replicate are pre-configured, so you can use AI blocks and many other features without providing your own API keys.
+
+### User-Provided Credentials
+
+For services tied to your personal accounts — such as Google, Linear, GitHub, or Twitter — you'll need to connect your own credentials. This only needs to be done **once per service per account**. After connecting, all agents that use that service will automatically have access.
+
+## Adding Credentials
+
+Credentials are added **in context** — when you encounter a block that needs them, rather than from a central setup page.
+
+### When Building an Agent
+
+If you add a block to the builder that requires a credential you haven't connected yet, a **credential bar** will appear on the block prompting you to add it.
+
+### When Running an Agent
+
+If you run an agent (including marketplace agents) that requires credentials, one of the input fields will be the credential selector. This only appears for services you haven't connected yet.
+
+### Credential Types
+
+Depending on the service, you'll be prompted to authenticate in one of three ways:
+
+| Type | Description | Example Services |
+|------|-------------|------------------|
+| **OAuth** | Click to authorise via the service's login page | Google, GitHub, Twitter |
+| **API Key** | Paste your API key from the service's dashboard | Linear, OpenAI (if self-hosting) |
+| **Username & Password** | Enter your account credentials | Varies by service |
+
+{% hint style="info" %}
+You only need to connect a credential **once per service**. For example, after adding your Linear API key, every agent that uses Linear blocks will have access automatically.
+{% endhint %}
+
+## Managing Credentials
+
+### Viewing Connected Integrations
+
+To view and manage your connected integrations:
+
+1. Click your **profile picture** in the top-right corner
+2. Select **Integrations**
+3. You'll see a list of all your connected integrations
+
+**URL:** [platform.agpt.co/profile/integrations](https://platform.agpt.co/profile/integrations)
+
+### Removing a Credential
+
+From the integrations page, you can **browse** your list of connected integrations and **delete** any you no longer need.
+
+{% hint style="warning" %}
+You **cannot add** new integrations from the integrations management screen. New credentials are only added when you encounter a block or agent that requires them.
+{% endhint %}
+
+## Self-Hosted Credentials
+
+If you're running the platform locally via self-hosting, you'll need to provide your own API keys for all services, including AI providers. These are configured in the `autogpt_platform/backend/.env` file. See the [Self-Hosting Guide](getting-started.md) for details.

docs/platform/marketplace.md

@@ -0,0 +1,82 @@
+# Marketplace
+
+## Overview
+
+The AutoGPT Marketplace is a public library of agents created by the community and by the AutoGPT team. You can discover agents for a wide range of use cases, add them to your library with one click, and even publish your own agents for others to use.
+
+**URL:** [platform.agpt.co/marketplace](https://platform.agpt.co/marketplace)
+
+**Access:** Click **Marketplace** in the navigation bar.
+
+## Browsing the Marketplace
+
+The marketplace allows you to:
+
+- **Search** for agents by name or keyword
+- **Browse by category** to explore different use cases
+- **View agent details** by clicking on any agent
+
+### Agent Detail Page
+
+Each agent in the marketplace has a dedicated page that includes:
+
+- **Title and description** of what the agent does
+- **Creator information** — who built the agent and a link to their other agents
+- **Video** (when available) — a demonstration of the agent in action
+- **Output showcase** (when available) — examples of the agent's results
+- **Instructions** — guidance on how to run the agent and what to expect
+
+## Adding an Agent to Your Library
+
+When you find an agent you want to use:
+
+1. Click on the agent to open its marketplace page
+2. Click the **Add to Library** button
+
+The agent will immediately appear in your [Agent Library](agent-library.md), where you can run it, schedule it, or edit it.
+
+{% hint style="info" %}
+If you already have the agent in your library, the button changes to **See Runs**, which takes you directly to that agent in your library.
+{% endhint %}
+
+### For Self-Hosted Users
+
+If you are not logged into the cloud platform and are instead self-hosting, you will see a **Download** button instead of "Add to Library". This downloads the agent as a file which you can import into your local instance. See [Download & Import an Agent](download-agent-from-marketplace-local.md) for details.
+
+## Publishing an Agent
+
+You can publish your own agents to the marketplace for the community to discover and use.
+
+### How to Publish
+
+1. Click your **profile picture** in the top-right corner of any screen
+2. Select **Publish an Agent**
+3. Choose the agent you want to publish from your list of recent agents
+4. Fill out the publishing form:
+
+| Field | Description |
+|-------|-------------|
+| **Title** | The name of your agent as it will appear in the marketplace |
+| **Subheader** | A short tagline for your agent |
+| **Slug** | A URL-friendly identifier (e.g., `resume-rewriter`) |
+| **Thumbnail Images** | Upload images — the first image becomes the marketplace thumbnail |
+| **YouTube Video Link** | Optional — a video demonstrating your agent |
+| **Category** | Select the most relevant category for your agent |
+| **Description** | A detailed explanation of what your agent does |
+| **Agent Output Demo** | Optional — a short video showing the agent's results in action |
+| **Instructions** | Explain to users how to run this agent and what to expect |
+| **Recommended Schedule** | Suggest when users should run this agent for best results |
+
+5. Click **Submit for Review**
+
+### Review Process
+
+After submission, a member of the AutoGPT team will review your agent against curation standards. If approved, your agent will be published to the marketplace and visible to all users.
+
+{% hint style="info" %}
+Creator monetisation (earning money from your published agents) is planned but not yet implemented.
+{% endhint %}
+
+## Editing Marketplace Agents
+
+When you add a marketplace agent to your library, you get your own copy. You are free to edit it in the builder just like any agent you've created yourself. Your changes only affect your copy — the original marketplace listing is not modified.

docs/platform/scheduling-and-triggers.md

@@ -0,0 +1,96 @@
+# Scheduling & Triggers
+
+## Overview
+
+AutoGPT agents can be run on demand, on a recurring schedule, or automatically in response to external events via webhooks. This guide covers both scheduling and trigger-based execution.
+
+## Scheduling an Agent
+
+Scheduling lets you run an agent automatically on a recurring basis with pre-configured inputs.
+
+### Setting Up a Schedule
+
+1. Go to your [Agent Library](agent-library.md) and open the agent you want to schedule
+2. Click **New Task** (the same button used for manual runs)
+3. Fill in all the input fields with the values you want the agent to use
+4. At the bottom of the input form, you'll see two buttons: **Start Task** and **Schedule Task**
+5. Click **Schedule Task**
+
+### Configuring the Schedule
+
+The schedule configuration screen allows you to set:
+
+| Setting | Description |
+|---------|-------------|
+| **Schedule Name** | A descriptive name for this schedule |
+| **Repeats** | Frequency — e.g., Weekly |
+| **Repeats On** | Select specific days (individual days, weekdays, weekends, or select all) |
+| **At** | The time of day to run (hour and minute) |
+| **Timezone** | Schedule runs in your local timezone, displayed on screen |
+
+**Example:** Run "Keyword SEO Expert" every weekday at 9:00 AM CST.
+
+### Managing Schedules
+
+After creating a schedule, you can view and manage it on your agent's detail page:
+
+- Open the agent from your library
+- Select the **Scheduled** tab on the left-hand side
+- The tab shows the count of active schedules (e.g., `Scheduled 1`)
+
+## Triggers (Webhook-Based Execution)
+
+Triggers allow external services or your own code to start an agent automatically by sending data to a webhook URL.
+
+### How Triggers Work
+
+Unlike standard input blocks, **trigger blocks** are a special type of input block. When you add a trigger block to your agent in the builder, the agent's execution model changes — instead of being started manually, it waits for incoming webhook events.
+
+### Setting Up a Trigger
+
+#### Step 1: Add a Trigger Block in the Builder
+
+1. Open the [Agent Builder](agent-builder-guide.md)
+2. From the blocks menu, add a **trigger block** to your agent
+3. Connect it to the rest of your workflow like any other input block
+4. Save your agent
+
+#### Step 2: Configure the Trigger in Your Library
+
+1. Go to your [Agent Library](agent-library.md) and open the agent
+2. Click **New Trigger** (this replaces the "New Task" button for trigger-based agents)
+3. Give the trigger a **name** and **description**
+
+#### Step 3: Copy the Webhook URL
+
+Once the trigger is created, you'll see a status panel:
+
+> **Trigger Status**
+>
+> Status: **Active**
+>
+> This trigger is ready to be used. Use the Webhook URL below to set up the trigger connection with the service of your choosing.
+>
+> **Webhook URL:** `https://backend.agpt.co/api/integrations/generic_webhook/webhooks/...`
+
+Copy this webhook URL and provide it to the external platform or code that will be sending events to trigger your agent.
+
+{% hint style="info" %}
+Trigger-based agents cannot be started manually with the "New Task" button. The only way to execute them is by sending data to the webhook URL.
+{% endhint %}
+
+### Example Use Cases
+
+- **GitHub webhook**: Trigger an agent whenever a pull request is opened
+- **Payment processor**: Run an agent when a new payment is received
+- **Form submission**: Process data when a user submits a form on your website
+- **Custom integration**: Send data from any service that supports webhooks
+
+## Schedule vs. Trigger
+
+| | Schedule | Trigger |
+|---|----------|---------|
+| **How it starts** | Automatically at configured times | When an external event sends data to the webhook URL |
+| **Input source** | Pre-configured when the schedule is created | Provided by the incoming webhook payload |
+| **Use case** | Recurring tasks with fixed inputs (daily reports, weekly summaries) | Event-driven tasks (new PR opened, form submitted, payment received) |
+| **Setup** | Through the "New Task" → "Schedule Task" flow | Through trigger blocks in the builder + "New Trigger" in the library |

docs/platform/sharing-and-exporting.md

@@ -0,0 +1,48 @@
+# Sharing & Exporting Agents
+
+## Overview
+
+There are several ways to share agents and their outputs with others on the AutoGPT Platform. This guide covers all the available options.
+
+## Sharing Options
+
+### Share Task Output via URL
+
+Every completed task has a unique URL that can be shared with others. To share a task result:
+
+1. Go to your [Agent Library](agent-library.md) and open the agent
+2. Click on the completed task you want to share
+3. Copy the task URL from your browser's address bar
+4. Send the URL to anyone — they can view the task's inputs and outputs directly
+
+### Publish to the Marketplace
+
+The most visible way to share an agent is to publish it to the [Marketplace](marketplace.md). Published agents are discoverable by all platform users and go through a review process by the AutoGPT team.
+
+See [Publishing an Agent](marketplace.md#publishing-an-agent) for the full guide.
+
+### Export as a File
+
+For sharing agents privately — without publishing to the marketplace — you can export an agent as a file:
+
+1. Go to your [Agent Library](agent-library.md) and open the agent
+2. Click the **three dots** (⋯) on the far right
+3. Select **Export Agent to File**
+4. The agent file will download to your computer
+
+You can then send this file to anyone via email, messaging, or any other method.
+
+### Import a Shared File
+
+To import an agent file someone has shared with you:
+
+1. Go to your [Agent Library](agent-library.md)
+2. Click **Upload Agent** at the top
+3. Select the agent file
+4. The agent will be added to your library
+
+## Teams & Collaboration
+
+{% hint style="info" %}
+Team and organisation features are not yet available on the platform. Currently, the only way to share agents privately between users is through the file export/import process described above.
+{% endhint %}

docs/platform/templates.md

@@ -0,0 +1,43 @@
+# Templates
+
+## Overview
+
+Templates are saved input configurations that let you re-run an agent with the same inputs quickly. Instead of filling in every input field each time, you can save a set of inputs as a template and trigger it again with one click.
+
+## Creating a Template
+
+Templates are created from previously completed tasks:
+
+1. Go to your [Agent Library](agent-library.md) and open the agent
+2. Find a completed task in the left-hand pane whose inputs you want to reuse
+3. Click the **three dots** (⋯) on the task
+4. Select **Save as Template**
+5. Give the template a **name** and **description**
+6. Click **Save**
+
+The template captures all the input values that were used for that task.
+
+## Using a Template
+
+To run an agent using a saved template:
+
+1. Open the agent from your library
+2. Switch to the **Templates** tab on the left-hand side
+3. Click on the template you want to use
+4. The agent will run with the saved input values
+
+## Managing Templates
+
+Templates are listed under the **Templates** tab on your agent's detail page. The tab shows the count of available templates (e.g., `Templates 3`).
+
+## When to Use Templates
+
+Templates are particularly useful for:
+
+- **Recurring tasks**: When you run an agent regularly with the same inputs (e.g., a daily SEO report for the same keyword)
+- **Standard configurations**: When you've found input settings that work well and want to reuse them
+- **Quick re-runs**: When you want to repeat a successful task without re-entering all the inputs
+
+{% hint style="info" %}
+Templates save the **input values** only — they do not save any settings or modifications to the agent itself. If you edit the agent's blocks or connections, existing templates will still use the saved input values with the updated agent design.
+{% endhint %}

docs/platform/what-is-autogpt-platform.md

@@ -78,5 +78,5 @@ This strategy allows us to share previously closed-source components, fostering
 
 ## Ready to Get Started?
 
-* Read the [Getting Started docs](getting-started.md) to self-host.
+* **Cloud:** Read the [Getting Started (Cloud)](getting-started-cloud.md) guide to start using the hosted platform immediately.
-* [Join the waitlist](https://agpt.co/waitlist) for the cloud-hosted beta.
+* **Self-Host:** Read the [Self-Hosting Guide](getting-started.md) to run the platform on your own infrastructure.