AutoGen-tutorial: bouw AI-toepassingen met meerdere agenten

Moderne AI begon met Large Language Models (LLM’s), gevolgd door function calling voor gestructureerde output, daarna de ontwikkeling van agents en tools, wat leidde tot de creatie van MCP-servers. Op dit moment ligt de focus op systemen met meerdere agents. Bedrijven zoeken oplossingen om intelligente, geautomatiseerde systemen te bouwen met diverse tools, waarbij AutoGen de populairste is.

In deze tutorial verkennen we AutoGen, het ecosysteem, de verschillende use-cases en hoe je elk onderdeel binnen dat ecosysteem gebruikt. Belangrijk om te weten: AutoGen is niet zomaar een orkestratietool voor taalmodellen zoals LangChain; het biedt veel meer dan dat.

Als je nieuw bent met AI, volg dan eerst de skill track AI Fundamentals voordat je met deze tutorial verdergaat. Je kunt ook meer lezen over Agentic AI in een apart artikel. 

Wat is AutoGen?

AutoGen is een open-source framework voor het bouwen van AI-toepassingen met meerdere agents die semi-autonoom en volledig autonoom kunnen werken. Het biedt ontwikkelaars tools om systemen te bouwen waarin meerdere AI-agents kunnen communiceren, samenwerken en samen taken uitvoeren.

AutoGen ondersteunt een breed scala aan use-cases, waaronder geautomatiseerde workflows, samenwerking tussen meerdere agents en dynamische taakoplossing. Ontwikkelaars kunnen systemen maken waarin agents via natuurlijke taal interacteren, code uitvoeren, informatie ophalen en zich aanpassen aan complexe workflows.

Het AutoGen-ecosysteem is onderverdeeld in vier hoofdcomponenten:

1. AutoGen Studio: Een no-code grafische interface voor het bouwen en testen van workflows met meerdere agents.
2. AutoGent AgentChat: Een vereenvoudigde API voor het bouwen van conversatie-applicaties met één of meerdere agents.
3. AutoGen Core: De basis-API voor het bouwen van schaalbare AI-systemen met meerdere agents. 
4. AutoGen Extension: Een bibliotheek met first- en third-party extensies die de mogelijkheden van het framework uitbreiden.

Bron: microsoft/AutoGen

AutoGen onderscheidt zich door het vermogen om:

• De orkestratie en optimalisatie van complexe LLM-workflows te vereenvoudigen.
• De prestaties van LLM’s te verbeteren en hun beperkingen aan te pakken.
• Naadloos systemen met meerdere agents te creëren die LLM’s, tools en menselijke input integreren.

De uitbreidbaarheid en modulariteit maken het een krachtig hulpmiddel voor ontwikkelaars in uiteenlopende sectoren, van financiën en zorg tot onderwijs en robotica.

Lees AI-agents begrijpen: de toekomst van autonome systemen om te leren hoe je AI-agents inzet voor innovatie en efficiëntie in je projecten.

Aan de slag met het AutoGen-ecosysteem

In deze sectie verkennen we de vier belangrijkste componenten van het AutoGen-ecosysteem door ze lokaal te installeren en uit te voeren.

1. AutoGen Studio

AutoGen Studio is een low-code interface waarmee je snel AI-agents kunt prototypen. Het biedt een gebruiksvriendelijke, drag-and-drop interface voor het bouwen van systemen met meerdere agents en om ze in realtime te testen.

1. Installeer Studio met het pip-commando.

pip install -U AutoGenstudio

2. Zodra het is geïnstalleerd, kun je de AutoGen Studio-UI starten door de poort en de app-map op te geven waar alle agents en templates worden opgeslagen. 

AutoGenstudio ui --port 8080 --appdir ./app

Na het uitvoeren van het commando zou je de volgende output in je terminal moeten zien:

INFO  [alembic.runtime.migration] Context impl SQLiteImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
2025-05-09 15:15:22.825 | INFO     | AutoGenstudio.web.app:lifespan:39 - Application startup complete. Navigate to http://127.0.0.1:8080

3. Ga in je browser naar http://127.0.0.1:8080 om toegang te krijgen tot het AutoGen Studio-dashboard.

Zodra de applicatie draait, word je begroet met een schone en intuïtieve gebruikersinterface.

AutoGen Studio biedt verschillende kernfeatures om je te helpen bij het bouwen en beheren van workflows met meerdere agents:

1. Team Builder: Een drag-and-drop interface voor het samenstellen van agentteams.
2. Playground: Een interactieve omgeving voor het testen en uitvoeren van agentworkflows.
3. Gallery: Een centraal overzicht om door communitycomponenten te bladeren en ze te importeren.
4. Labs: Een experimentele functie in AutoGen Studio waarmee je geavanceerde workflows kunt verkennen en grensverleggende ideeën kunt prototypen.
5. Deploy: Exporteer en voer agentworkflows uit als Python-code.

AutoGen Studio is een low-code applicatie, wat betekent dat je workflows kunt bouwen met minimale code. Tegelijk biedt het de flexibiliteit om agents en workflows te customizen met Python-code.

2. AutoGen AgentChat

AgentChat is een high-level framework voor het creëren van conversatieworkflows met meerdere agents. Het vereenvoudigt het bouwen van applicaties waarin meerdere agents (AI, tools of mensen) samenwerken om taken op te lossen. 

Installeer eerst de benodigde pakketten:

pip install -U "AutoGen-agentchat" "AutoGen-ext[openai]"

Vervolgens richten we drie agents in—een gebruiker, een coder en een code-executor—die samenwerken in een round-robin groepschat om Python-code te genereren, uit te voeren en te beschrijven. Het systeem is ontworpen voor dynamische codegeneratie en -uitvoering, met ruimte voor menselijke interactie en beëindigingscondities.

In dit voorbeeld gebruiken we het gpt-4.1-mini-model voor codegeneratie, CodeExecutorAgent voor commandline-code-uitvoering,  en UserProxyAgent om de mens in de lus te houden. 

import asyncio
from pathlib import Path

from AutoGen_agentchat.agents import AssistantAgent, CodeExecutorAgent, UserProxyAgent
from AutoGen_agentchat.conditions import TextMentionTermination
from AutoGen_agentchat.teams import RoundRobinGroupChat
from AutoGen_agentchat.ui import Console
from AutoGen_ext.code_executors.local import LocalCommandLineCodeExecutor
from AutoGen_ext.models.openai import OpenAIChatCompletionClient

async def main() -> None:
    model_client = OpenAIChatCompletionClient(model="gpt-4.1-mini")

    coder = AssistantAgent(
        "coder",
        model_client=model_client,
        system_message=(
            "You are a senior engineer. Think step-by-step, then output ONLY runnable "
            "Python inside ```pythonthon``` blocks—no commentary."
        ),
    )

    executor = CodeExecutorAgent(
        "executor",
        model_client=model_client,  # lets it narrate results
        code_executor=LocalCommandLineCodeExecutor(work_dir=Path.cwd() / "runs"),
    )

    user = UserProxyAgent("user")  # human in the loop

    termination = TextMentionTermination("exit", sources=["user"])
    team = RoundRobinGroupChat(
        [user, coder, executor], termination_condition=termination
    )

    try:
        await Console(
            team.run_stream()
        )
    finally:
        await model_client.close()

if __name__ == "__main__":
    asyncio.run(main())

Sla de bovenstaande code op in een bestand chat_app.py en voer het uit met:

python chat_app.py 

We hebben de Agent-applicatie gevraagd code te genereren om sterren in een driehoeksvorm te printen, en vervolgens de code uit te voeren. 

De code werd succesvol gegenereerd en uitgevoerd, met aanvullende opties erbij. De gebruiker kan “exit” typen om te stoppen of vervolgvragen stellen voor een conversatie-ervaring.

Output: 

Enter your response: Write a Python script that prints stars and run it.
---------- TextMessage (user) ----------
Write a Python script that prints stars and run it.

---------- TextMessage (coder) ----------
# Print a simple star pattern
for i in range(1, 6):
    print('*' * i)

---------- CodeGenerationEvent (executor) ----------
# Print a simple star pattern
for i in range(1, 6):
    print('*' * i)

---------- CodeExecutionEvent (executor) ----------

*

**

***

****

*****

---------- TextMessage (executor) ----------

The star pattern has been printed successfully. If you'd like a different pattern or further modifications, just let me know!

Enter your response:

3. AutoGen Core

AutoGen Core is een low-level framework dat een krachtige manier biedt om systemen met meerdere agents te maken en te beheren. 

In dit voorbeeld maken we twee agents: een Echo-agent die de inhoud van een bericht omkeert en een Printer-agent die de berichtinhoud naar de console print.

pip install "autogen-core"

Componenten die in deze applicatie worden gebruikt:

1. Berichtstructuur: De klasse Text is een eenvoudige datastructuur die de inhoud van een bericht bevat.

2. Echo-agent: De Echo-agent keert de inhoud om van elk bericht dat hij ontvangt en publiceert het omgekeerde bericht naar het standaardtopic met publish_message.

3. Printer-agent: De Printer-agent luistert naar berichten en print de inhoud naar de console.

4. Runtime: De SingleThreadedAgentRuntime wordt gebruikt om de levenscyclus van de agents te beheren en berichtroutering af te handelen.

import asyncio
from dataclasses import dataclass

from AutoGen_core import (
    AgentId,
    DefaultTopicId,
    MessageContext,
    RoutedAgent,
    SingleThreadedAgentRuntime,
    default_subscription,
    message_handler,
)

@dataclass
class Text:
    content: str

@default_subscription
class Echo(RoutedAgent):
    def __init__(self) -> None:
        super().__init__("echo")

    @message_handler
    async def handle(self, message: Text, ctx: MessageContext) -> None:  # param must be named 'message'
        await self.publish_message(Text(message.content[::-1]), DefaultTopicId())

@default_subscription
class Printer(RoutedAgent):
    def __init__(self) -> None:
        super().__init__("printer")

    @message_handler
    async def handle(self, message: Text, ctx: MessageContext) -> None:  # param must be named 'message'
        print(message.content)

async def main() -> None:
    rt = SingleThreadedAgentRuntime()
    await Echo.register(rt, "echo", lambda: Echo())
    await Printer.register(rt, "printer", lambda: Printer())
    rt.start()
    await rt.send_message(Text("DataCamp"), AgentId("echo", "default"))
    await rt.stop_when_idle()

if __name__ == "__main__":
    asyncio.run(main())

Sla de code op in een bestand core_app.py en voer het uit met:

python core_app.py            

Berichtenstroom:

• Een bericht met de inhoud "DataCamp" wordt naar de Echo-agent gestuurd.
• De Echo-agent keert het bericht om naar "pmaCataD" en publiceert het.
• De Printer-agent ontvangt het omgekeerde bericht en print het naar de console.

Output: 

pmaCataD

4. AutoGen Extensions

Het AutoGen Extensions-framework biedt first- en third-party extensies die de mogelijkheden van het framework uitbreiden. 

In dit voorbeeld laten we zien hoe je de MultimodalWebSurfer-agent gebruikt, die met webpagina’s kan interageren, zoekopdrachten kan uitvoeren en informatie kan extraheren. 

Zorg ervoor dat je Playwright hebt geïnstalleerd voordat je het voorbeeld uitvoert:

playwright install 

Zo werkt de code: 

1. Agent-initialisatie: Er wordt een MultimodalWebSurfer-agent gemaakt, die OpenAI’s gpt-4.1-mini-model gebruikt voor besluitvorming en een browser (via Playwright) voor webinteracties.
2. Teamopzet: De agent wordt toegevoegd aan een RoundRobinGroupChat-team, dat de workflow van de agent beheert en de taak beperkt tot 3 beurten.
3. Taakuitvoering: Het team krijgt de instructie: "Navigeer naar Google en zoek informatie over Abid Ali Awan." De agent opent een browser, gaat naar Google, voert de zoekopdracht uit en haalt relevante informatie op.
4. Streaming output: De acties van de agent (zoals naar een pagina navigeren, op links klikken, metadata extraheren) worden in realtime naar de console gestreamd.
5. Opschonen: Na voltooiing van de taak wordt de browser gesloten om resources vrij te geven.

import asyncio
from AutoGen_agentchat.ui import Console
from AutoGen_agentchat.teams import RoundRobinGroupChat
from AutoGen_ext.models.openai import OpenAIChatCompletionClient
from AutoGen_ext.agents.web_surfer import MultimodalWebSurfer

async def main() -> None:
    # Define an agent
    web_surfer_agent = MultimodalWebSurfer(
        name="MultimodalWebSurfer",
        model_client=OpenAIChatCompletionClient(model="gpt-4.1-mini"),
    )

    # Define a team
    agent_team = RoundRobinGroupChat([web_surfer_agent], max_turns=3)

    # Run the team and stream messages to the console
    stream = agent_team.run_stream(task="Navigate to Google and search about Abid Ali Awan.")
    await Console(stream)
    # Close the browser controlled by the agent
    await web_surfer_agent.close()

asyncio.run(main())

Sla de code op in een bestand, web_ext_app.py, en voer het uit met:

python web_ext_app.py          

Als je de applicatie uitvoert, vindt de volgende interactie plaats:

                                                           
---------- TextMessage (user) ----------
Navigate to Google and search about Abid Ali Awan.
---------- MultiModalMessage (MultimodalWebSurfer) ----------
I typed 'https://www.google.com' into the browser address bar.

The web browser is open to the page [Google](https://www.google.com/).
The viewport shows 100% of the webpage, and is positioned at the top of the page
The following text is visible in the viewport:

Gmail
Images
Sign in
Google offered in:
اردو
پښتو
سنڌيPakistan
About
Advertising
Business
 How Search works
Privacy
Terms
Settings
Google recommends using Chrome
Try a fast, secure browser with updates built in
Don't switch
Yes

The following metadata was extracted from the webpage:

{
    "microdata": [
        {
            "itemType": "http://schema.org/WebPage",
            "image": "/images/branding/googleg/1x/googleg_standard_color_128dp.png"
        }
    ],
    "meta_tags": {
        "referrer": "origin"
    }
}

Here is a screenshot of the page.
<image>
---------- MultiModalMessage (MultimodalWebSurfer) ----------
I clicked 'Sign in'.

The web browser is open to the page [Sign in - Google Accounts](https://accounts.google.com/v3/signin/identifier?continue=https%3A%2F%2Fwww.google.com%2F&ec=futura_exp_og_so_72776762_e&hl=en&ifkv=ASKV5MhAzFZnwDH-Aw10tuqQN1ppsY8OZ2-OJ3YavFHXMDlX9iTddg1d_k78ZZ0SogFUivcY7Td0Hg&passive=true&flowName=GlifWebSignIn&flowEntry=ServiceLogin&dsh=S1980923188%3A1746809726624486).
The viewport shows 100% of the webpage, and is positioned at the top of the page
The following text is visible in the viewport:

Sign inUse your Google AccountEmail or phone
Forgot email?
Not your computer? Use a private browsing window to sign in.
Learn more about using Guest modeNext
Create account
English (United States)
Help
Privacy
Terms
Sign in Use your Google Account

The following metadata was extracted from the webpage:

{
    "meta_tags": {
        "referrer": "origin",
        "chrome": "nointentdetection",
        "viewport": "width=device-width, initial-scale=1",
        "description": ""
    }
}

Here is a screenshot of the page.
<image>
---------- TextMessage (MultimodalWebSurfer) ----------
Please provide the email or phone number you want to use to sign in, or let me know if you want to create a new account or need help with something else on this page.

Net als AutoGen is CrewAI een ander favoriet framework onder AI-fans voor het bouwen van agentic workflows. Volg de tutorial CrewAI: een gids met voorbeelden van systemen met meerdere AI-agents om er meer over te leren.

Use-cases voor AutoGen

AutoGen opent talloze mogelijkheden om intelligente systemen met meerdere agents te creëren. Dit zijn enkele van de meest prominente use-cases binnen het AutoGen-ecosysteem:

1. Codegeneratie, -uitvoering en -debugging: Automatiseert codetaken, vermindert fouten en verbetert de efficiëntie.
2. Samenwerking tussen meerdere agents: Maakt teamwork tussen agents mogelijk om complexe taken op te lossen.
3. Sequentiële multi-agent-chats: Beheert gestructureerde taakreeksen voor efficiënte afronding.
4. Geneste chats: Handelt complexe taken af via gedetailleerde, gelaagde gesprekken.
5. Toolgebruik: Breidt de functionaliteit van agents uit door tools als websearch en SQL-queries te integreren.
6. Menselijke betrokkenheid: Neemt menselijke feedback op om workflows te verbeteren.
7. Agents leren en onderwijzen: Verbetert de vaardigheden en kennis van agents.
8. Multi-agent-chat met OpenAI Assistants: Combineert de mogelijkheden van OpenAI met AutoGen voor geavanceerde taken.
9. Multimodale agent: Verwerkt tekst, afbeeldingen en andere media voor rijkere interacties.
10. Omgaan met lange contexten: Behoudt samenhang in langere gesprekken.

Conclusie

Er is een reden waarom AutoGen zoveel aandacht en erkenning heeft gekregen en behoort tot de meest ‘gestarrede’ agentic frameworks op GitHub. 

Het is een allesomvattend framework dat geschikt is voor iedereen: van professionele ontwikkelaars tot casual programmeurs en zelfs mensen zonder enige codeerervaring. 

Met AutoGen kun je snel workflows prototypen met AutoGen Studio, robuuste applicaties bouwen met het Core-framework en Extensions, en ze naadloos in de cloud deployen. Het is echt een alles-in-één oplossing voor het creëren en beheren van intelligente systemen met meerdere agents.

Volg de cursus Dynamische LangChain-agents bouwen en leer je eerste AI-agentapplicatie bouwen met het populaire LLM-framework.