AutoGPT-gids: autonome AI-agents lokaal maken en implementeren

Het AutoGPT Platform is een platform waarmee gebruikers continue AI-agents kunnen maken, implementeren en beheren. Het gebruikt een low-code UI zodat gebruikers duizenden digitale processen kunnen automatiseren, met agents die autonoom op de achtergrond draaien.

Het AutoGPT Platform heeft twee kernonderdelen: de AutoGPT Server — de hoofdlogica en infrastructuur — en de AutoGPT Frontend — de UI voor het bouwen van agents, het beheren van workflows en het inplannen van terugkerende taken. 

Het is vooraf geïntegreerd met LLM-providers zoals OpenAI, Anthropic, Groq en Llama, zodat een breed scala aan taken zoals gegevensverwerking, contentcreatie of zelfs leuke activiteiten geautomatiseerd kan worden. 

In deze tutorial laten we technische professionals zien hoe je het AutoGPT-platform lokaal opzet en je eerste agent maakt. Je kunt onze volledige gids AI-agents begrijpen lezen voor meer achtergrond, en in een apart artikel de verschillende typen AI-agents ontdekken. 

Wat is AutoGPT?

AutoGPT is een AI-platform/software waarmee gebruikers autonome AI-agents kunnen maken, implementeren en beheren. Deze agents kunnen verschillende taken uitvoeren met minimale menselijke supervisie via een low-code interface die op de machine van de gebruiker is geïnstalleerd. 

Op het moment van schrijven is er een open wachtlijst voor een aankomende cloudversie van AutoGPT als je de rompslomp van een lokale setup wilt vermijden.

Belangrijke functies en mogelijkheden van AutGPT zijn:

• Low-code workflows: Maak workflows zonder uitgebreide programmeerkennis.
• Autonome werking: Implementeer agents die continu draaien en activeren op specifieke triggers.
• Intelligente automatisering: Automatisch herhalende processen voor gegevensverwerking, contentcreatie en andere taken.
• Blokgebaseerd systeem: Bouw agents met modulaire blokken die verschillende acties en integraties vertegenwoordigen.
• Ondersteuning voor meerdere LLM's: Compatibel met OpenAI, Anthropic, Groq en Llama.
• Marktplaats: Toegang tot vooraf geconfigureerde agents voor specifieke use-cases.

Overzicht van de AutoGPT-architectuur

Het AutoGPT-platform bestaat uit twee hoofdonderdelen:

1. AutoGPT-server:

• Kernlogica voor agents en automatisering
• Infrastructuur voor betrouwbare prestaties
• Marktplaats voor kant-en-klare agents

2. AutoGPT-frontend:

• Agent builder voor het ontwerpen en configureren van agents
• Tools voor workflowbeheer
• Implementatieregelaars
• Selectie van kant-en-klare agents
• Monitoring- en analysedashboard

De backend van AutoGPT gebruikt Python met FastAPI als webframework en PostgreSQL met Prisma ORM voor dataopslag. Het gebruikt websockets voor realtime-communicatie en bevat managers voor uitvoering, planning en meldingen. 

Dit ontwerp verbetert de schaalbaarheid en het onderhoud naarmate het platform groeit.

De frontend gebruikt Next.js 14 met TypeScript, Radix-componenten en Tailwind CSS, met workflowvisualisatie via xyflow. Dit creëert een intuïtieve low-code interface waarmee gebruikers AI-agents kunnen bouwen zonder uitgebreide programmeerkennis.

Het platform bevat deze kernservices:

• Databasemanager: Slaat agentconfiguraties en uitvoeringsdata op
• Uitvoeringsmanager: Voert workflows uit en beheert de status van agents
• Planner: Behandelt tijdsgebaseerde automatisering en terugkerende taken
• Websocket-server: Biedt realtime-updates
• REST API: Biedt programmatische toegang tot functies
• Agentprotocol: Standaardiseert communicatie met externe services
• Integratie-API's: Verbindt met services van derden en AI-providers

AutoGPT in 2025 vs oudere versies

Toen het rond 2023 voor het eerst werd aangekondigd, schoot AutoGPT in populariteit en werd het gezien als de open-source-killer van ChatGPT. Dat bleek natuurlijk vooral hype, aangejaagd door socialmediainfluencers, want het is nu 2025 en ChatGPT is er nog steeds. Maar AutoGPT markeerde wel de verschuiving in focus binnen de AI-community richting AI-agents.

De eerdere versies van AutoGPT beloofden volledig autonome agents die on the fly vanuit één prompt konden worden gebouwd. Het zou de prompt kunnen opdelen in behapbare taken en een reeks tools, software en API's aan elkaar kunnen knopen om het werk te doen, terwijl het zowel kortetermijn- als langetermijngeheugen had, versterkt door een zelf-reflecterende feedbackloop. 

Onderweg zullen ze echter de beperkingen van deze aanpak hebben ingezien vanwege de inherente onvoorspelbaarheid van LLM's in productieomgevingen.

Tegenwoordig is AutoGPT niet dat “prompt-naar-agent”-platform maar iets veel beters — een low-code platform dat de gebruiker de controle geeft over hoe agents worden gebouwd. Je ziet deze verschuiving van de oorspronkelijke versie van AutoGPT naar het platform dat we in 2025 hebben als je posts van 1–2 jaar geleden leest of YouTube-video's bekijkt. 

Die posts laten totaal andere installatie-instructies en workflowvoorbeelden zien dan wat ik je nu ga leren.

Dus zonder verder oponthoud: zo zet je het platform op je machine op.

AutoGPT-installatie en -configuratie

AutoGPT lokaal opzetten vereist de juiste configuratie van je ontwikkelomgeving en begrip van containerisatietools — volg onze cursus over Containerization and Virtualization with Docker and Kubernetes als je een opfrisser nodig hebt. In dit deel nemen we je mee door het volledige proces, van vereisten tot het voor het eerst draaien van het platform.

Vereisten en omgevingssetup

Zorg vóór de installatie van AutoGPT dat je het volgende hebt:

1. Node.js & NPM

• Mac:
• brew install node
• Linux/WSL2:
• sudo apt update sudo apt install nodejs npm
• Controleer de installatie:
• node -v npm -v

2. Docker & Docker Compose

• Mac: Download en installeer Docker Desktop
• Linux (WSL2 wordt al met de Docker-kernel geleverd en vereist installatie):
• sudo apt update sudo apt install docker.io docker-compose sudo systemctl enable --now docker
• Controleer de installatie:
• docker -v docker compose -v

3. Git

• Mac:
• brew install git
• Linux/WSL2:
• sudo apt update sudo apt install git

Kloon de AutoGPT-repository:

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

Deze vereisten zijn essentieel om AutoGPT effectief te draaien. Node.js en NPM zijn nodig voor de frontendapplicatie, zodat je via een gebruiksvriendelijke interface met AutoGPT kunt werken. 

Docker en Docker Compose maken geïsoleerde containers die consistente prestaties op verschillende systemen garanderen en het uitrollen van de backendservices eenvoudiger maken. Met Git kun je de repository klonen en bijblijven met de nieuwste verbeteringen.

Na deze stap staat de AutoGPT-map op je machine, met alles om de applicatie te draaien. Het enige dat rest is configuratie.

Lokaal hosten met Docker 

Docker biedt een geïsoleerde, consistente omgeving voor het draaien van AutoGPT, zodat alle dependencies correct werken, ongeacht je hostsysteem.

1. Richt de backendservices in

cd AutoGPT/autogpt_platform
cp .env.example .env
docker compose up -d --build

Het nieuwe .env-bestand bevat omgevingsvariabelen met verstandige standaardwaarden. Je bent niet per se verplicht dit bestand zelf te configureren, maar de aanwezigheid ervan is wel vereist. Het wordt door de frontendapplicatie gebruikt wanneer je verschillende sleutels en secrets opgeeft tijdens het maken van je aangepaste agents.

Het laatste docker compose-commando kan de eerste keer tot wel 15 minuten duren, afhankelijk van je internetsnelheid. Het richt de backendcomponenten in waarmee de frontend verbinding maakt.

2. Richt de frontendapplicatie in

cd frontend
cp .env.example .env
npm install
npm run dev

Deze commando's zetten het omgevingsbestand voor de frontend op, installeren de dependencies met Node.js en starten de UI.

3. Controleer de installatie

• Ga naar de AutoGPT-UI op http://localhost:3000
• Backendservices draaien op poorten:
• WebSocket-server: 8001
• Execution API: 8006

Als je poort 3000 bezoekt, zou je de Marketplace-UI moeten zien, waarmee je je account aanmaakt en inlogt.

4. Pas je encryptiesleutel aan (optioneel maar aanbevolen)

# Generate a new key with Python
from cryptography.fernet import Fernet
Fernet.generate_key().decode()

# Or use the built-in CLI
poetry run cli gen-encrypt-key

Vervang de bestaande sleutel in autogpt_platform/backend/.env door je nieuwe sleutel.

Opmerking voor Windows-gebruikers: Gebruik bij Docker op Windows WSL 2 in plaats van Hyper-V tijdens de installatie om compatibiliteitsproblemen met Supabase te voorkomen. Als je al met Hyper-V hebt geïnstalleerd, kun je in de instellingen van Docker Desktop overschakelen naar WSL 2.

Overzicht van de AutoGPT-gebruikersinterface

Voordat we een werkende agent maken, verkennen we eerst even de builderinterface van AutGPT.

De interface is een groot leeg canvas met vier hoofdknoppen:

• Blokken
• Ongedaan maken/Opnieuw-knoppen
• Opslaan

Klikken op “Blokken” opent een menu met de ingebouwde herbruikbare componenten van AutoGPT, gegroepeerd in categorieën.

Deze blokken bieden essentiële tools die in veel agentscenario's universeel toepasbaar zijn. 

Hieronder heb ik bijvoorbeeld twee blokken gezocht en toegevoegd — lange-tekst-invoer en AI-tekstgenerator. Met deze twee componenten kan ik de basisversie van de ChatGPT-interface nabouwen:

Op de afbeelding zie je dat elk blok verschillende onderdelen heeft. Het invoerblok heeft velden voor de bloknaam en een standaardwaarde, terwijl de tekstgenerator een veld heeft voor de prompt, het model en promptvariabelen. 

Laatstgenoemde heeft ook een eenmalig invoerveld voor je OpenAI API-sleutel, die je moet opgeven vóórdat je de agent draait (doe dat nu). Het API-sleutelveld verandert op basis van het model dat je kiest en AutoGPT ondersteunt de meeste grote en kleinere aanbieders.

Als je goed kijkt, hebben beide blokken kleine randjes (kijk naar 3 en 5) waarmee je ze kunt verbinden:

In de afbeelding hierboven geef ik het invoerblok een naam (1) en een standaardwaarde (2), en verbind ik het tekstresultaat (3) met het promptveld (4) van de tekstgenerator. Deze verbinding creëert een basisworkflow voor de agent, die kan worden uitgevoerd nadat je de agent zelf hebt opgeslagen (stappen 5–8).

Na het klikken op Run verschijnt er een pop-upmenu “Run settings” voor het invoerveld:

Schrijf je prompt en voer alles uit om je eerste output te krijgen, zoals hieronder:

Je merkt misschien dat de modelrespons lastig te lezen is in het grotere tekstgeneratorblok. Daarom heeft AutoGPT blokken voor agentoutputs, die ik hieronder toevoeg:

Let op hoe ik het responseveld van de tekstgenerator verbind met de waarde van het agent-outputblok. Door een outputblok toe te voegen, kun je ook alle agentoutputs van verschillende blokken op één plek bekijken via het “Agent Outputs”-paneel:

Zodra je je agent opslaat, wordt deze in je bibliotheek bewaard. Bovendien kan deze hele agent daarna als blok worden gebruikt in andere agents die je maakt. Deze modulaire aanpak biedt verschillende voordelen:

1. Herbruikbaarheid: Je kunt complexe functionaliteit opnieuw gebruiken in meerdere projecten zonder deze opnieuw op te bouwen.
2. Composabiliteit: Je kunt verschillende agents combineren om geavanceerdere workflows te maken.
3. Onderhoudbaarheid: Als je de oorspronkelijke agent bijwerkt, profiteren alle instanties die deze als blok gebruiken van de verbeteringen.
4. Abstractie: Complexe processen kunnen in één blok worden ingekapseld, waardoor je hoofdworkflows schoner en begrijpelijker blijven.
5. Samenwerking: Je kunt gespecialiseerde agentblokken delen met teamleden of de community, wat de ontwikkeling versnelt.

Met deze bouwstenenaanpak kun je steeds krachtigere AI-systemen creëren door mogelijkheden op elkaar te stapelen.

Aangepaste blokken in AutoGPT schrijven in Python

Overzicht van de syntax en het algemene proces

De kracht van AutoGPT komt uit het modulaire bloksysteem. Hoewel het platform veel nuttige ingebouwde blokken bevat, kun je de mogelijkheden uitbreiden door je eigen aangepaste blokken in Python te maken. Zo kun je integreren met elke API, service of tool die programmatisch toegankelijk is.

Een aangepast blok maken omvat deze essentiële stappen:

1. Maak een nieuw Python-bestand in de map autogpt_platform/backend/backend/blocks met snake_case-benaming
2. Definieer een klasse die erft van de Block-basisklasse
3. Maak input- en outputschema's met behulp van BlockSchema om de datastructuur te definiëren
4. Implementeer de __init__-methode met een unieke ID en testdata
5. Schrijf de run-methode met de kernlogica van je blok
6. Ga goed om met fouten zodat het blok netjes faalt
7. Test je blok met de testinfrastructuur van het platform

Laten we elk onderdeel in detail doornemen:

Structuur van de Block-klasse

Elk blok moet erven van de Block-basisklasse en zijn input-/outputspecificaties definiëren:

from backend.data.block import Block, BlockSchema, BlockOutput

class MyCustomBlock(Block):
   class Input(BlockSchema):
       # Define input fields with types
       field1: str
       field2: int
      
   class Output(BlockSchema):
       # Define output fields with types
       result: str
       error: str  # Always include an error field
      
   def __init__(self):
       super().__init__(
           id="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",  # Generate proper UUID
           input_schema=MyCustomBlock.Input,
           output_schema=MyCustomBlock.Output,
           test_input={"field1": "test", "field2": 42},
           test_output=("result", "expected output"),
           test_mock=None  # Only needed for external API calls
       )
      
   def run(self, input_data: Input, **kwargs) -> BlockOutput:
       try:
           # Your block logic here
           result = f"Processed {input_data.field1} and {input_data.field2}"
           yield "result", result
       except Exception as e:
           raise RuntimeError(f"Error in block: {str(e)}")

Belangrijke onderdelen

1. Input-/outputspecificaties: definieer de datastructuur met typehints
2. UUID-generatie: gebruik een juiste UUID-generator (verzin er geen zelf)
3. Testdata: voorzie in realistische testinputs en verwachte outputs
4. Foutenafhandeling: voeg altijd degelijke foutenafhandeling toe in de run-methode
5. Resultaten opleveren: gebruik yield om resultaten één voor één uit te geven

Een voorbeeld van een aangepast blok

Laten we een uitgebreid voorbeeld maken van een aangepast blok dat sentimentsanalyse uitvoert met de OpenAI API. Dit laat zien hoe je integreert met externe AI-services en API-sleutels veilig afhandelt.

Installatiestappen voor de OpenAI API-sleutel

Voordat je dit blok gebruikt, moet je je OpenAI API-sleutel instellen:

1. Installeer de vereiste pakketten:

• pip install openai python-dotenv

2. Maak een .env-bestand in de map autogpt_platform/backend/blocks met je OpenAI API-sleutel:

• OPENAI_API_KEY=your_api_key_here

Laten we nu het blok maken:

Imports en omgevingssetup

Allereerst regelen we de imports en de omgevingssetup:

# autogpt_platform/backend/blocks/sentiment_analyzer.py
from backend.data.block import Block, BlockSchema, BlockOutput
from typing import Dict, Any, List
import os
from dotenv import load_dotenv
from openai import OpenAI
import json

# Load environment variables from .env file
load_dotenv()

Dit deel importeert de benodigde libraries en laadt omgevingsvariabelen uit het .env-bestand. De functie load_dotenv() zorgt dat je API-sleutel beschikbaar is via os.getenv().

Definieer het blokkenschema en initialiseer

Vervolgens definiëren we de blokklasse met input- en outputschema's:

class OpenAISentimentBlock(Block):
   """Block to analyze sentiment of text using OpenAI API"""
  
   class Input(BlockSchema):
       text: str  # Text to analyze
       model: str = "gpt-3.5-turbo"  # OpenAI model to use
       detailed_analysis: bool = False  # Whether to return detailed analysis
      
   class Output(BlockSchema):
       sentiment: str  # Positive, Negative, or Neutral
       confidence: float  # Confidence score of the prediction
       explanation: str  # Brief explanation of the sentiment
       detailed_analysis: Dict[str, Any]  # Optional detailed analysis
       error: str  # Error message if analysis fails

Het inputschema definieert drie parameters:

• text: De inhoud om te analyseren (vereist)
• model: Het te gebruiken OpenAI-model (standaard "gpt-3.5-turbo")
• detailed_analysis: Of er extra details moeten worden teruggegeven (standaard False)

Het outputschema definieert de structuur van de resultaten, inclusief de sentimentcategorie, confidencescore, uitleg en optionele gedetailleerde analyse.

Initialiseer het blok met testdata

De __init__-methode zet het blok op met testdata en initialiseert de OpenAI-client:

def __init__(self):
   super().__init__(
       id="8f67d394-9f52-4352-a78b-175d5d1d7182",  # Generated UUID
       input_schema=OpenAISentimentBlock.Input,
       output_schema=OpenAISentimentBlock.Output,
       test_input={
           "text": "I really enjoyed this product, it exceeded my expectations!",
           "detailed_analysis": True
       },
       test_output=[
           ("sentiment", str),
           ("confidence", float),
           ("explanation", str),
           ("detailed_analysis", dict)
       ],
       test_mock={
           "_analyze_sentiment": lambda text, model, detailed: {
               "sentiment": "positive",
               "confidence": 0.92,
               "explanation": "The text expresses clear enjoyment and states that expectations were exceeded.",
               "detailed_analysis": {
                   "emotions": {
                       "joy": "high",
                       "satisfaction": "high",
                       "disappointment": "none"
                   },
                   "key_phrases": ["really enjoyed", "exceeded expectations"],
                   "tone": "enthusiastic"
               }
           }
       }
   )
   # Initialize OpenAI client
   api_key = os.getenv("OPENAI_API_KEY")
   if not api_key:
       raise RuntimeError("OpenAI API key not found. Please set OPENAI_API_KEY in .env file.")
   self.client = OpenAI(api_key=api_key)

Deze methode:

• Stelt realistische testinputs en verwachte outputs in voor testen
• Levert een mock voor de sentimentsanalysefunctie om API-calls tijdens tests te vermijden
• Initialiseert de OpenAI-client met de API-sleutel uit omgevingsvariabelen
• Gooit een fout als de API-sleutel ontbreekt

Implementeer de sentimentsanalysemethode

De kernfunctionaliteit wordt geïmplementeerd in de _analyze_sentiment-methode:

@staticmethod
def _analyze_sentiment(self, text: str, model: str, detailed: bool) -> Dict[str, Any]:
   """Analyze sentiment using OpenAI API"""
   # Create prompt based on whether detailed analysis is requested
   if detailed:
       system_prompt = """
       You are a sentiment analysis expert. Analyze the following text and provide:
       1. The overall sentiment (positive, negative, or neutral)
       2. A confidence score from 0.0 to 1.0
       3. A brief explanation of your assessment
       4. A detailed analysis including:
          - Key emotions detected and their intensity
          - Key phrases that influenced your assessment
          - Overall tone of the text
      
       Format your response as a JSON object with the following structure:
       {
           "sentiment": "positive|negative|neutral",
           "confidence": 0.0-1.0,
           "explanation": "brief explanation",
           "detailed_analysis": {
               "emotions": {"emotion1": "intensity", "emotion2": "intensity"},
               "key_phrases": ["phrase1", "phrase2"],
               "tone": "description of tone"
           }
       }
       """
   else:
       system_prompt = """
       You are a sentiment analysis expert. Analyze the following text and provide:
       1. The overall sentiment (positive, negative, or neutral)
       2. A confidence score from 0.0 to 1.0
       3. A brief explanation of your assessment
      
       Format your response as a JSON object with the following structure:
       {
           "sentiment": "positive|negative|neutral",
           "confidence": 0.0-1.0,
           "explanation": "brief explanation"
       }
       """
  
   try:
       # Make API call using the latest OpenAI API syntax
       response = self.client.chat.completions.create(
           model=model,
           response_format={"type": "json_object"},
           messages=[
               {"role": "system", "content": system_prompt},
               {"role": "user", "content": text}
           ],
           temperature=0.2  # Low temperature for more consistent results
       )
      
       # Extract and parse JSON response
       content = response.choices[0].message.content
       result = json.loads(content)
      
       return result
      
   except Exception as e:
       raise RuntimeError(f"OpenAI API error: {str(e)}")

Deze methode:

• Maakt een andere systemprompt op basis van de vraag of gedetailleerde analyse gewenst is
• Gebruikt de OpenAI API om een gestructureerde sentimentsanalyse te genereren
• Stelt een lage temperatuur (0,2) in voor consistentere resultaten
• Parset de JSON-respons en geeft die terug
• Handelt uitzonderingen af die tijdens de API-call kunnen optreden

Implementeer de run-methode

Tot slot brengt de run-methode alles samen:

def run(self, input_data: Input, **kwargs) -> BlockOutput:
   try:
       # Validate input
       if not input_data.text or not isinstance(input_data.text, str):
           raise ValueError("Text must be a non-empty string")
      
       # Process through OpenAI
       results = self._analyze_sentiment(
           input_data.text,
           input_data.model,
           input_data.detailed_analysis
       )
      
       # Yield the results
       yield "sentiment", results["sentiment"]
       yield "confidence", results["confidence"]
       yield "explanation", results["explanation"]
      
       # Only return detailed analysis if requested and available
       if input_data.detailed_analysis and "detailed_analysis" in results:
           yield "detailed_analysis", results["detailed_analysis"]
      
   except ValueError as e:
       raise RuntimeError(f"Input validation error: {str(e)}")
   except Exception as e:
       raise RuntimeError(f"Sentiment analysis failed: {str(e)}")

Deze methode:

• Valideert de invoertekst
• Roept de sentimentsanalysemethode aan met de invoerparameters
• Geeft de resultaten één voor één terug met het sleutelwoord yield
• Geeft alleen een gedetailleerde analyse terug als daarom is gevraagd en als die beschikbaar is
• Handelt verschillende soorten fouten af met passende meldingen

Belangrijke aspecten van dit voorbeeld

1. OpenAI API-integratie: gebruikt de nieuwste OpenAI API-syntax met het chatcompletions-endpoint
2. Veilige omgang met API-sleutels: laadt de API-sleutel via omgevingsvariabelen met dotenv
3. Aanpasbare analyse: biedt basis- of gedetailleerde sentimentsanalyse op basis van gebruikersvoorkeur
4. Gestructureerde output: geeft sentimentcategorie, confidencescore, uitleg en optionele gedetailleerde analyse terug
5. JSON-verwerking: verwerkt gestructureerde JSON-responses van OpenAI
6. Teststrategie: mockt de OpenAI API-call om te testen zonder echte API-credits te gebruiken

Dit blok laat zien hoe je integreert met state-of-the-art AI-services om de mogelijkheden van je agents uit te breiden. De OpenAI-integratie maakt verfijnde tekstanalyse mogelijk die lastig te implementeren is met simpele regelgebaseerde aanpakken.

Denk bij het schrijven van je eigen blokken altijd aan:

• Hoe je veilig met API-sleutels omgaat
• Duidelijke foutmeldingen bij API-falen
• Inputs ontwerpen die flexibiliteit bieden in het gebruik van het blok
• Outputs structureren zodat downstream-blokken ze gemakkelijk kunnen gebruiken

Voor meer details over het maken van aangepaste blokken, waaronder veldtypen, authenticatie, webhookintegratie en best practices, zie de officiële AutoGPT Block-documentatie.

Conclusie

AutoGPT biedt een krachtig platform voor het maken en implementeren van autonome AI-agents via een intuïtieve, blokgebaseerde interface. Deze tutorial heeft je meegenomen door het hele proces — van lokale installatie en configuratie tot het begrijpen van de UI, het maken van basisagents en het uitbreiden van functionaliteit met aangepaste blokken. 

Door de modulaire architectuur van AutoGPT te omarmen kunnen technische professionals complexe workflows automatiseren zonder veel code, met toch de flexibiliteit om waar nodig maatwerk toe te voegen.

Voor wie hierop wil voortbouwen en AI-agents verder wil verkennen, biedt de officiële AutoGPT-documentatie uitgebreide begeleiding, terwijl DataCamp aanvullende bronnen biedt zoals AI-agents begrijpen en ChatGPT Fundamentals. 

De cursus Introduction to GPTs helpt je begrip van large language models te verdiepen, terwijl RAG-chatbots bouwen voor technische documentatie een andere praktische toepassing van AI-agents laat zien. Terwijl je verder experimenteert met AI-agents, wil je misschien ook nieuwe tools bekijken zoals de Mistral Agents API, Dify AI en Langflow.