KI-Agenten Workflow Manager: Content-Produktion mit Multi-Agent-Orchestrierung automatisieren

💰 Warum sich ein Multi-Agent-System rechnet

Content-Produktion ist teuer — ein Social-Media-Post kostet extern 80–150 €, ein Video-Script 200–500 €. Mit einem orchestrierten Team aus spezialisierten KI-Agenten (lokal via Ollama) fallen diese Kosten auf nahe Null. Der Workflow-Manager verteilt Aufgaben automatisch an den richtigen Agenten.

⚙️ So funktioniert's

Vier Schritte vom Prompt zur fertigen Content-Ausgabe — orchestriert durch spezialisierte Agenten.

💻 Technische Umsetzung

Das System ist eine native PyQt6-Desktop-Anwendung mit Drag & Drop Editor, visueller Workflow-Ansicht und Echtzeit-Chat. Die Agenten kommunizieren über die Ollama-API mit lokal gehosteten LLMs — kein Internet, keine Cloud.

🏗️ Architektur

🐍 Der OllamaAgent — universelle LLM-Schnittstelle

class OllamaAgent:
    def __init__(self, settings_path="llm_settings.json"):
        with open(settings_path, 'r') as f:
            self.settings = json.load(f)
        self.debug = self.settings.get('show_debug', False)

    def chat(self, message, system_prompt=None, model=None,
             temperature=None, num_predict=None, address=None, port=None):
        current_model = model or self.settings.get('model')
        current_temp = temperature or self.settings.get('temperature', 0.7)
        current_num_predict = num_predict or self.settings.get('num_predict', 128)
        current_address = address or self.settings.get('address', 'localhost')
        current_port = port or self.settings.get('port', '11434')

        client = Client(host=f"http://{current_address}:{current_port}")

        messages = []
        if system_prompt:
            messages.append({'role': 'system', 'content': system_prompt})
        messages.append({'role': 'user', 'content': message})

        response = client.chat(
            model=current_model,
            messages=messages,
            options={'temperature': current_temp, 'num_predict': current_num_predict}
        )
        return response.message.content

🖱️ Drag & Drop Workflow-Editor

class DraggableAgentWidget(QWidget):
    def mousePressEvent(self, event):
        if event.button() == Qt.MouseButton.LeftButton:
            drag = QDrag(self)
            mime = QMimeData()
            mime.setText(self.agent_type)
            drag.setMimeData(mime)
            drag.exec()

class WorkflowScene(QGraphicsScene):
    def dropEvent(self, event: QDropEvent):
        agent_type = event.mimeData().text()
        pos = event.scenePos()
        new_node = AgentNode(agent_type)
        new_node.setPos(pos)
        self.addItem(new_node)
        # Auto-Verbindung zum nächstgelegenen Node
        if not self.root_node:
            self.root_node = new_node
        else:
            closest_node = self.findClosestNode(pos)
            if closest_node:
                closest_node.children.append(new_node)
                new_node.parent_node = closest_node
                self.arrangeNodes()

🤖 Die 4 spezialisierten Agenten-Typen

⚙️ Konfiguration per JSON

{
  "model": "llama2",
  "temperature": 0.7,
  "num_predict": 128,
  "address": "localhost",
  "port": "11434",
  "show_debug": false
}

🚀 Gebaut mit Vibecoding — in 5–7 Tagen statt 8–13 Wochen

🗣️ Der System-Prompt hinter diesem Projekt

Dieser Prompt erzeugte in wenigen Iterationen eine vollständige PyQt6-Desktopanwendung mit Drag & Drop, visuellem Workflow-Editor und Multi-Agent-Orchestrierung:

Du bist ein PyQt6-Experte für Desktop-Anwendungen mit KI-Integration.

Aufgabe: Erstelle einen KI-Agenten Workflow-Manager mit grafischer 
Oberfläche. Die Anwendung soll es ermöglichen, spezialisierte KI-Agenten 
per Drag & Drop in einem visuellen Editor zu platzieren und zu verbinden.

Technische Anforderungen:
- PyQt6 für die GUI (QMainWindow, QGraphicsScene, QGraphicsView)
- Drag & Drop von Agenten-Widgets aus einer Seitenleiste in die Workflow-Area
- Jeder Agent als visueller Node (QGraphicsItem) mit individuellem Aussehen
- Konfigurations-Dialog pro Agent (Modell, Temperatur, System-Prompt)
- Ollama-Integration über ollama Python-Client
- Chat-Funktion: CEO-Agent nimmt Anfragen entgegen und delegiert
- Serialisierung: Workflows als JSON speichern/laden
- Zoom-Funktionalität mit Mausrad
- Auto-Arrange: Automatisches Anordnen der Nodes im Baum-Layout

Agenten-Typen:
1. CEO Agent — Orchestrator, analysiert und delegiert
2. Social Media Agent — Plattform-spezifische Posts
3. Video Script Agent — Drehbücher und Storyboards
4. Bild Generator Agent — KI-Bild-Prompts

Code-Struktur:
- agent.py: OllamaAgent-Klasse für LLM-Kommunikation
- main.py: GUI, Drag & Drop, Workflow-Logik

Output: Vollständige, ausführbare .py-Dateien mit Fehlerbehandlung und 
Debug-Modus. Deutsche UI-Texte. Produktionsreife Code-Qualität.

🎯 Strategische Erkenntnisse aus diesem Projekt

Multi-Agent-Systeme sind der nächste Evolutionsschritt nach einzelnen KI-Assistenten. Die Orchestrierung spezialisierter Agenten liefert bessere Ergebnisse als ein einzelner Generalist.