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

Der zentrale Baustein: Eine flexible Klasse, die alle Ollama-Parameter dynamisch übernimmt:

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

Agenten-Widgets aus der Seitenleiste per Drag & Drop in die Workflow-Area ziehen:

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()

🎛️ Agent-Konfigurations-Dialog

Jeder Agent bekommt seinen eigenen Konfigurations-Dialog mit vorausgefüllten System-Prompts:

class AgentConfigDialog(QDialog):
    def __init__(self, agent_type, parent=None):
        super().__init__(parent)
        self.setWindowTitle(f"Konfiguration: {agent_type}")
        
        # Modell-Einstellungen
        self.model = QComboBox()
        self.model.addItems(["llama2", "mistral", "codellama", "neural-chat"])
        self.temperature = QDoubleSpinBox()
        self.temperature.setRange(0.0, 1.0)
        self.temperature.setValue(0.7)
        self.num_predict = QSpinBox()
        self.num_predict.setRange(1, 2048)
        self.num_predict.setValue(128)

        # System Prompt — vorausgefüllt je nach Agenten-Typ
        self.system_prompt = QTextEdit()
        if agent_type == "CEO Agent":
            self.system_prompt.setText(
                "Du bist der CEO eines KI-Agenten-Teams. "
                "Deine Aufgabe ist es, Anfragen zu analysieren "
                "und an die passenden Spezialisten weiterzuleiten..."
            )
        elif agent_type == "Video Script Agent":
            self.system_prompt.setText(
                "Du bist ein Video Script Experte. "
                "Erstelle Drehbücher und Storyboards..."
            )

🔗 Workflow-Serialisierung als JSON

Gesamte Workflows speichern und wiederherstellen — inklusive aller Agent-Konfigurationen:

def serialize_workflow(self):
    workflow = {'nodes': []}
    for item in self.workflow_area.scene.items():
        if isinstance(item, AgentNode):
            node_data = {
                'type': item.agent_type,
                'pos': {'x': item.pos().x(), 'y': item.pos().y()},
                'config': item.config,
                'parent': None if not item.parent_node else 
                         self.workflow_area.scene.items().index(item.parent_node)
            }
            workflow['nodes'].append(node_data)
    return workflow

def deserialize_workflow(self, workflow_data):
    self.workflow_area.scene.clear()
    nodes = []
    # Erstelle zuerst alle Nodes
    for node_data in workflow_data['nodes']:
        node = AgentNode(node_data['type'])
        node.setPos(node_data['pos']['x'], node_data['pos']['y'])
        node.config = node_data['config']
        if node.config:
            node.status = "Konfiguriert ✓"
        self.workflow_area.scene.addItem(node)
        nodes.append(node)
    # Stelle dann die Verbindungen her
    for i, node_data in enumerate(workflow_data['nodes']):
        if node_data['parent'] is not None:
            parent_node = nodes[node_data['parent']]
            parent_node.children.append(nodes[i])
            nodes[i].parent_node = parent_node

🎨 Visuelle Nodes mit Status-Anzeige

Custom QGraphicsItems mit Tooltips, Kontextmenü und Doppelklick-Konfiguration:

class AgentNode(QGraphicsItem):
    def __init__(self, agent_type, parent=None):
        super().__init__(parent)
        self.agent_type = agent_type
        self.config = {}
        self.children = []
        self.parent_node = None
        self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsMovable)
        self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsSelectable)
        self.status = "Nicht konfiguriert"
        self.status_color = QColor("#ff0000")

    def paint(self, painter: QPainter, option, widget):
        # Schatten
        painter.setBrush(QColor(0, 0, 0, 30))
        painter.drawRoundedRect(3, 3, self.width, self.height, 10, 10)
        # Hauptrechteck
        painter.setBrush(QBrush(QColor("#ffffff")))
        painter.drawRoundedRect(0, 0, self.width, self.height, 10, 10)
        # Titel & Status
        painter.drawText(10, 30, self.agent_type)
        painter.setPen(self.status_color)
        painter.drawText(10, 50, self.status)

    def configure(self):
        dialog = AgentConfigDialog(self.agent_type)
        if dialog.exec():
            self.config = {
                "model": dialog.model.currentText(),
                "temperature": dialog.temperature.value(),
                "system_prompt": dialog.system_prompt.toPlainText()
            }
            self.status = "Konfiguriert ✓"
            self.status_color = QColor("#00ff00")

🤖 Die 4 spezialisierten Agenten-Typen

⚙️ Konfiguration per JSON

Minimale Konfigurationsdatei für den schnellen Einstieg:

{
  "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.