Die Druckversion wird nicht mehr unterstützt und kann Darstellungsfehler aufweisen. Bitte aktualisiere deine Browser-Lesezeichen und verwende stattdessen die Standard-Druckfunktion des Browsers.

aiMOOC

Mehrere KI-Agenten in einem Softwareprojekt koordinieren

QR-Code

Zielgruppe: Auszubildende im 2. bis 3. Ausbildungsjahr mit A1 oder Grundlagen in Python, Dateien, Git und einfachen Tests. Zeitbedarf: etwa 5 bis 7 Unterrichtsstunden. Lernprodukt: Agentenplan mit Dateibesitz, Übergabeformat, Konfliktprotokoll und Integrationsnachweis. Alle Beispiele sind synthetisch, offline ohne bezahltes KI-Konto bearbeitbar und betreffen nur Simulationen ohne reale Maschinensteuerung oder Sicherheitsfreigaben.

Einleitung

Mehrere KI-Agenten können zeitgleich an einem Softwareprojekt arbeiten. Ohne feste Zuständigkeiten entstehen jedoch doppelte Änderungen, widersprüchliche Schnittstellen und unklare Verantwortung. Du lernst, Überschneidungen zu erkennen, Konflikte ohne Verlust zu lösen und die Integration zu prüfen. Der Modellfall ist eine fiktive Messdaten-App, die eine Importprüfung und Tests erhält. Am Schluss begründest du eine eigene Entscheidung für oder gegen Parallelität.

Vorwissen aktivieren: Erkläre in einem Satz Branch, Commit und automatischen Test. Kontrolliere im Übungsrepository git status und git diff. Die vom Auftrag vorgegebene MOOCwiki-Grundlage ist als Anschlusskurs verlinkt, war jedoch beim Recherchezugriff nicht abrufbar. Deshalb werden ihre Inhalte nicht behauptet oder vorausgesetzt.

Lernweg: Verständnis der Rollen → Arbeitsplan → geführte Python-Übung → Konfliktentscheidung → Qualitätsnachweis → eigenständiger Transfer.

Rollen, Arbeitsteilung und begrenzte Zuständigkeit

Was ein koordiniertes Agententeam ausmacht

Ein KI-Agent ist in diesem Kurs eine begrenzte Bearbeiterrolle, die anhand eines Arbeitsauftrags Vorschläge oder Teständerungen erzeugt. Der Orchestrator verteilt Aufträge, synchronisiert Ergebnisse und organisiert Rückfragen. Parallelität heißt, dass Bearbeitungen zeitlich überlappen. Das kann Durchlaufzeit sparen, muss es aber nicht: Übergaben, gegenseitige Abhängigkeiten, zusätzliche Kontrollen und Fehlerbehebung kosten ebenfalls Zeit. Bei einer sehr kleinen Änderung ist oft ein einzelner verantwortlicher Bearbeiter die bessere Wahl.

Im Modellteam bearbeitet Agent A die Importlogik, Agent B schreibt Integrationstests und Agent C kontrolliert nur lesend die Beiträge. Die menschliche Projektleitung definiert den gemeinsamen Vertrag, entscheidet bei Konflikten und genehmigt die Integration. Keiner der Agenten darf eigenständig den geschützten Hauptzweig überschreiben.

Dateibesitz, Vertrag und Rechte

Dateibesitz meint die vereinbarte Schreibzuständigkeit für konkrete Dateien. Schnittstellenvertrag meint definierte Funktionsnamen, Parameter, Ergebnisse und Ausnahmen. Least Privilege meint minimal erforderliche Befugnisse: Leserechte sind keine Schreibrechte; Testergebnisse sind keine Freigabe.

Bearbeiter	Auftrag	Schreibbereich	Grenze
Agent A	Eingabeprüfung bauen	`messdaten.py`, `tests/test_import.py`	kein direkter Merge nach main
Agent B	Zusammenspiel testen	`tests/test_integration.py`	kein Schreiben in `messdaten.py`
Agent C	unabhängigen Diff- und Risiko-Bericht erstellen	keine Quelldatei	keine Selbstfreigabe
Menschliche Leitung	Vertrag und Freigabe verantworten	`schnittstelle.md`, `README.md`, `main`	keine ungeprüfte Übernahme

Überschneidung erkennen: Vergleiche die geplanten Schreibpfade und anschließend die tatsächlich geänderten Pfade der Agenten. Eine Datei in beiden Schreibmengen ist ein Warnsignal. Aber auch ohne gemeinsame Datei können Änderungen unvereinbar sein, wenn B den alten Funktionsnamen testet, A ihn jedoch verändert. Deshalb sind Pfadvergleich und Vertragsprüfung erforderlich.

Ohne Bild: Zeichne von einem gemeinsamen Startpunkt main zwei Zweige A und B. Beide liefern Änderungen; erst nach Kontrolle gehen sie in den Hauptzweig. Die Quelle, Urheber und Lizenz findest du im Medienverzeichnis.

Agentenplan, Schnittstellen und Übergaben

Der schriftliche Agentenplan als Lernprodukt

Bevor ein Agent beginnt, lege verbindlich fest: Ziel, Zuständigkeit, erlaubte Dateipfade, Ausgangscommit, Branch, Schnittstelle, Fehlerfälle, Übergabeformat, Prüfkriterien und Eskalationsweg. Notiere explizit, dass keiner der Agenten Rechte an fremden Dateien, Zugangsdaten oder realen Anlagen erhält. Vertragsänderungen werden nicht von einzelnen Agenten stillschweigend durchgeführt, sondern an die Projektleitung zurückgemeldet.

Vertrag der Messdaten-App: Textzeilen mit Kennung;Wert verarbeiten. parse_zeile(text) liefert (kennung, float) oder löst ValueError aus. importiere(text) liefert eine Liste gültiger Messwerte. Nur genau zwei Felder mit Semikolon, nichtleerer Kennung und endlichem Zahlenwert mit Dezimalpunkt sind gültig. Leerzeilen werden übersprungen, ungültige befüllte Zeilen nicht heimlich korrigiert.

Bereich	Verbindliche Vereinbarung
Agent A	Branch `feature/import`, Besitzer der Importimplementierung und ihrer Einzeltests
Agent B	Branch `feature/integration`, Besitzer der Integrationstests, nutzt nur vereinbarte Schnittstelle
Agent C	Prüft nur Diffs, Vertragstreue und Nachweise, ändert keinen Anwendungscode
Leitung	Genehmigt Änderungen am Vertrag und führt den Integrationsbranch zusammen
Stoppregel	Fremder Schreibpfad, inkompatible Signatur, offener Konflikt, gescheiterter Test oder fehlendes Review

Übergabeformat statt bloßer Erfolgsmeldung

Ein überprüfbarer Übergabezettel enthält Auftrag, Basis-Commit, Ergebnis-Commit, erlaubte und tatsächlich geänderte Pfade, Funktionsvertrag, Testkommando, dokumentiertes Resultat, bekannte Risiken, offene Fragen und Reviewperson. Ein Commit ist eine Versionskennung, keine Qualitätsgarantie. „Fertig“ ohne Diff und Testprotokoll ist keine belastbare Übergabe.

Musterübergabe – rein fiktiv: Agent A meldet die Verwerfung von NaN, nennt messdaten.py und tests/test_import.py als Änderungen, hält den Vertrag unverändert und empfiehlt die Ausführung von python -m unittest discover -s tests -v. Der Eintrag „fünf Tests erfolgreich“ darf erst nach realem Lauf in ein echtes Protokoll. Beim Papierreview lautet der Status ausdrücklich „simuliert“.

Bild- und Audiobeispiel

Bildalternative: Beide Arbeitszweige behalten vor dem Merge ihre Geschichte. Beim Zusammenführen muss geprüft werden, ob beide fachlichen Anforderungen erhalten bleiben.

Datei:Git Basics 02 - Was ist Git (Deutsch).webm

Audio-/Videoalternative: Ein verteiltes Versionssystem bewahrt lokal Commits; getrennte Zweige erlauben parallele Arbeit; Merge ist eine technische Zusammenführung, die fachliche Abstimmung nicht ersetzt. Dieses ältere Original besitzt eine 2026 erstellte inoffizielle deutsche Bearbeitung mit synthetischer Stimme. Oberflächen können veraltet sein; die Rechte und Urheber sind am Kursende genannt.

Geführtes Beispiel: Importprüfung und Integrationstests

Schritt 1: synthetische Eingaben spezifizieren

Die App verarbeitet nur erfundene Zeichenfolgen. T1;21.5 ist gültig. ;12 hat keine Kennung. T2;NaN ist keine endliche Zahl. T3;18;5 hat zu viele Spalten. Für T4;21,5 ist das Dezimalkomma gemäß diesem bewusst engen Vertrag nicht zugelassen. Entscheide erst über Regeln, dann über Code.

Schritt 2: Agent A erstellt die Importfunktion

Schreibe in einem isolierten lokalen Ordner messdaten.py. Das folgende Beispiel ist vollständiger Python-Standardbibliothekscode und benötigt keine externe KI:

import math

def parse_zeile(zeile):
    teile = zeile.strip().split(";")
    if len(teile) != 2 or not teile[0].strip():
        raise ValueError("Kennung oder Spaltenzahl ungueltig")
    try:
        wert = float(teile[1])
    except ValueError as fehler:
        raise ValueError("Wert ist keine Zahl") from fehler
    if not math.isfinite(wert):
        raise ValueError("Wert ist nicht endlich")
    return teile[0].strip(), wert

def importiere(text):
    ergebnis = []
    for zeile in text.splitlines():
        if zeile.strip():
            ergebnis.append(parse_zeile(zeile))
    return ergebnis

Die Aufteilung in parse_zeile und importiere macht den Vertrag testbar. math.isfinite schließt unendliche Zahlen und NaN aus. Der Code ist absichtlich ein Lernmodell ohne Dateigrößenlimit, Sensorkopplung, Zeilennummern im Fehlerbericht oder Produktionsfreigabe. Notiere diese Grenzen.

Schritt 3: Agent B definiert fünf unabhängige Testfälle

Lege tests/test_integration.py an. Die Python-Standardbibliothek unittest steht ohne Zusatzkonto zur Verfügung.

import unittest
from messdaten import importiere, parse_zeile

class MessdatenIntegration(unittest.TestCase):
    def test_gueltige_zeile(self):
        self.assertEqual(parse_zeile("T1;21.5"), ("T1", 21.5))

    def test_zwei_zeilen(self):
        self.assertEqual(
            importiere("T1;21.5\nT2;19.0"),
            [("T1", 21.5), ("T2", 19.0)]
        )

    def test_kennung_fehlt(self):
        with self.assertRaises(ValueError):
            parse_zeile(";12")

    def test_nan_verworfen(self):
        with self.assertRaises(ValueError):
            parse_zeile("T2;NaN")

    def test_spaltenzahl_falsch(self):
        with self.assertRaises(ValueError):
            importiere("T3;18;5")

Die fünf Fälle prüfen Normalfall, Zusammenspiel und drei Fehlerfälle. Agent B verändert nur diese Testdatei; bei einer unpassenden Implementierung beantragt er eine Vertragsklärung anstatt fremden Code zu überschreiben.

Schritt 4: die Ergebnisse kontrolliert übergeben

Im Übungsprojekt lautet der Aufruf python -m unittest discover -s tests -v. Führe ihn nach Möglichkeit selbst aus und sichere den konsistenten Commit sowie die Ausgabe. Anschließend gleiche git diff und git status mit dem Agentenplan ab. Vermerke in einem Übergabezettel das tatsächlich beobachtete Ergebnis. Ist kein Rechner verfügbar, führe alle fünf Testfälle als schriftliche Simulation durch und behaupte keinen automatischen Testlauf.

Optionales deutsches YouTube-Video: „Lerne Git in 60 Minuten“ von Mit Mario erklärt Branching, Merging und Konfliktbehebung. Ohne Video: Lies die Git-Schritte und löse die folgenden Fallbeispiele; das Video ist keine Voraussetzung. Die Metadaten wurden öffentlich geprüft, die künftige Wiedergabe bleibt ungewiss.

Überschneidungen und Konflikte ohne Verlust lösen

Drei unterschiedliche Konflikte

Besitzkonflikt: Agent B möchte entgegen dem Plan messdaten.py ändern. Textueller Mergekonflikt: Zwei Branches ändern dieselbe Stelle in einer Datei widersprüchlich; Git kennzeichnet den Konflikt. Semantischer Konflikt: Ein Agent benennt parse_zeile in parse_row um, während der andere ohne gemeinsame Dateibearbeitung den alten Aufruf testet. Git kann die Dateien dabei konfliktfrei vereinigen; erst der Integrationstest deckt den Fehler auf. Eine fehlende Konfliktmeldung ist deshalb kein Integrationsnachweis.

Beispiel einer fehlerhaften Agentenentscheidung

Agent A behandelt T2;NaN korrekt als ungültig. Agent B überschreitet sein Schreibrecht und ersetzt in messdaten.py ungültige Werte durch 0.0. Würde ein Integrator blind die letzte Änderung übernehmen, ginge eine fachliche Schutzregel verloren. Halte den Vorgang an und sichere beide Branches und ihre Commits. Vergleiche die Änderungen und den vereinbarten Vertrag. Entscheide begründet: Ungültige Messwerte dürfen nicht als scheinbar gültige Nullen erscheinen. In einem neuen nachvollziehbaren Korrekturcommit entfernst du nur die unzulässige Verhaltensänderung, erhältst die gültigen Tests und führst sämtliche Prüfungen neu aus. Die menschliche Projektleitung trifft die Entscheidung.

Sechs-Schritte-Nachweis: Originalstände erhalten → Pfade und Diffs vergleichen → Vertragsverletzung benennen → erlaubte Lösung dokumentieren → Integrationstests am zusammengeführten Stand prüfen → unabhängiges Review mit menschlicher Freigabe. Lösche niemals blind einen fremden Branch oder erzwinge einen Merge mit zerstörenden Befehlen. Bei fehlenden Nachweisen gilt Stoppen und klären.

Bildalternative: Von einem Ausgangscommit zweigen zwei unabhängige Wege ab. Bei ihrem Zusammentreffen müssen alle relevanten zulässigen Änderungen berücksichtigt werden.

Werkzeuge erklären statt auf Knöpfe vertrauen

git status zeigt den Zustand des Arbeitsverzeichnisses, git diff die Unterschiede, git log vorhandene Commits. Ein Merge-Vorgang versucht Änderungen zusammenzuführen, entscheidet aber nicht automatisch über ihre fachliche Sicherheit. Reproduzierbare Tests und Review prüfen deshalb zusätzlich die fachliche Bedeutung.

Bildalternative: add bereitet Änderungen für einen Commit vor; commit speichert lokal; fetch lädt entfernte Versionsstände; merge vereint Zweige. Keiner dieser Schritte ist automatisch eine Berechtigung zur Freigabe.

Integration, Qualitätssicherung und sichere Agentengrenzen

Die gemeinsame Prüfschleuse

Eine Quality Gate genannte Prüfschwelle macht die Weitergabe von beobachtbaren Nachweisen abhängig. Ein Test muss sich auf die tatsächlich integrierte Version beziehen, nicht nur auf einen früher erfolgreichen Einzelbranch.

Kontrolle	Beobachtbarer Nachweis	Stoppgrund
Überschneidung	geänderte Pfade gegen Besitzliste geprüft	unvereinbarte Dateiänderung
Schnittstelle	Funktionsnamen Eingaben und Fehlerregeln verglichen	inkompatibler Vertrag
Tests	fünf Testfälle am vereinigten Stand protokolliert	Test fehlgeschlagen oder nicht ausgeführt
Merge	beide Ausgangsversionen nachvollziehbar keine offenen Marker	Arbeit verloren oder Konflikt ungeklärt
Review	eigenständiger lesender Bericht und menschliche Entscheidung	keine unabhängige Genehmigung

Kriterium 1 prüfen: A ändert messdaten.py, B ebenfalls: Konflikt bereits anhand der Besitzliste. Kriterium 2 prüfen: Beim Wert NaN darf eine Änderung nur dann übernommen werden, wenn die festgelegte Ablehnung erhalten bleibt; dokumentiere den Gegenentwurf. Kriterium 3 prüfen: Die fünf Tests müssen nach dem Zusammenführen erfolgreich sein, ein Revisionsbezug und getrenntes Review müssen vorliegen. Erläutere jede Entscheidung selbst und nenne mindestens einen Fehlerfall.

Menschliche Kontrolle, Prompt Injection und Berechtigungen

Eine Prompt Injection ist die unberechtigte Übernahme von Anweisungen aus unzuverlässigen Quellen, etwa einem Kommentar im Quellcode oder einer fremden Webseite. Solche Texte sind Daten, keine neuen Arbeitsaufträge. Kein Agent erhält geheime Schlüssel, umfassende Schreibrechte, Produktionszugang oder die Möglichkeit, seine eigene Arbeit endgültig freizugeben. Besonders bei Tool-Schnittstellen sind Scope-Begrenzung, getrennte Berechtigungen und kontrollierte Übergaben wichtig.

Die Security Best Practices des Model Context Protocol behandeln unter anderem Tokenweitergabe, Stellvertreterprobleme, Schutz vor missbräuchlichen Werkzeugaufrufen und minimale Scopes. NIST AI 600-1 (Juli 2024) ist ein freiwilliges Profil für den Umgang mit Risiken generativer KI, keine automatische Prüfung und keine Zertifizierung. Daraus folgt für dieses Lernprojekt: Risiken ausdrücklich benennen, Gegenmaßnahmen prüfen und verbleibende Unsicherheit dokumentieren.

Zukunftsakzent: mehr Parallelität, aber engere Grenzen

Vergleiche die Modelle zentraler Orchestrator und Peer-Koordination. Ein zentraler Plan erleichtert die Kontrolle, kann jedoch zum Engpass werden. Gleichberechtigte Agenten stimmen sich flexibel ab, benötigen dafür eindeutige Regeln für Besitz, Eskalation und Freigabe. Besonders riskante oder gemeinsame Vertragsänderungen sollten sequenziell entschieden werden, während unabhängig testbare Aufgaben parallel laufen dürfen. Eine größere Agentenzahl garantiert weder mehr Geschwindigkeit noch weniger Fehler: Das muss gemessen werden.

Optionales englisches YouTube-Video: Tech With Tim erklärt Tests mit pytest. Für die Pflichtaufgaben ist ausschließlich die kostenfreie Python-Standardbibliothek nötig. Ohne Video: Überprüfe den dargestellten unittest-Code mit fünf Beispielen und erkläre, warum ein Integrationstest mehr als einen Funktionsaufruf absichern kann.

Interaktive Aufgaben

Quiz: Wissen anwenden

Was beschreibt sinnvolle parallele Arbeitsteilung? (Getrennte Schreibrechte mit einem gemeinsamen Schnittstellenvertrag) (!Beliebiger Dateizugriff für alle Agenten) (!Nur möglichst viele gleichzeitig gestartete Agenten) (!Alle Freigaben automatisch an Agenten übertragen)

Woran erkennt man eine direkte Besitzüberschneidung? (Agent B verändert die für Agent A reservierte Datei messdaten.py) (!Agent B bearbeitet seine erlaubte Testdatei) (!Agent C liest nur einen Prüfbericht) (!Die Leitung pflegt eine vereinbarte Dokumentation)

Warum genügt ein konfliktfreier Git-Merge nicht? (Weil getrennte Dateien unvereinbare Funktionsnamen verwenden können) (!Weil Git überhaupt keine Änderungen zusammenführen kann) (!Weil alle Tests nach einem Merge ungültig sind) (!Weil zwei Agenten immer dieselbe Datei besitzen müssen)

Was ist laut Importvertrag mit T2;NaN zu tun? (Eine ValueError auslösen) (!Den Wert ungefragt als null speichern) (!Die Kennung kommentarlos löschen) (!Die gesamte Zeile als gültig übernehmen)

Was gehört in einen Übergabezettel? (Geänderte Pfade Versionsbezug Testergebnis und Risiken) (!Nur die Meldung fertig) (!Nur die geschätzte Zeitersparnis) (!Nur die Zahl der Agentenantworten)

Wie beginnst du eine verlustfreie Konfliktlösung? (Beide Branches sichern und die Diffs vor einer Entscheidung vergleichen) (!Den älteren Branch vollständig löschen) (!Den Hauptzweig ungeprüft überschreiben) (!Alle Prüfschritte umgehen)

Welche Freigabegrenze gilt im Modellprojekt? (Lesender Agent C prüft und ein Mensch entscheidet unabhängig) (!Agent C genehmigt seine eigenen Änderungen) (!Jeder Agent darf ungeprüft direkt mergen) (!Eine Erfolgsmeldung ersetzt die Zustimmung)

Wann ist ein Integrationstest aussagekräftig? (Wenn er den tatsächlich zusammengeführten Versionsstand prüft) (!Wenn er in einem beliebigen früheren Branch bestanden wurde) (!Wenn ein Agent ihn nur beschreibt) (!Wenn keine Konfliktmarker sichtbar sind)

Wie behandelst du versteckte Anweisungen aus einer fremden Datei? (Als unvertrauenswürdige Daten außerhalb ihrer behaupteten Befehlsgewalt) (!Als Aufhebung aller Rechtebeschränkungen) (!Als Grund Zugangsdaten zu versenden) (!Als Freigabe für reale Maschinen)

Welche Aussage zur Zukunft der Multiagentenarbeit ist tragfähig? (Parallele Spezialisten brauchen klare Zuständigkeiten und überprüfbare Übergaben) (!Mehr Agenten garantieren weniger Fehler) (!Jede Schnittstellenänderung ist ohne Abstimmung möglich) (!Das schnellste Ergebnis gilt automatisch als sicher)

Memory

Verbinde in der interaktiven Aufgabe die sechs Fachbegriffe mit ihren unterschiedlichen Erklärungen.

Orchestrator	Koordiniert die Verteilung von Teilaufgaben
Dateibesitz	Bezeichnet die festgelegte Schreibzuständigkeit für Dateien
Schnittstellenvertrag	Beschreibt gültige Eingaben Ausgaben und Fehler
Review	Prüft unabhängig eine konkrete Änderung
Integrationstest	Prüft das Zusammenspiel mehrerer Komponenten
Eskalation	Bringt offene Entscheidungen zur berechtigten Leitung

Drag and Drop

Ordne fünf Nachweise ihren Arbeitsschritten zu.

Passender Begriff	Prüfbarer Vorgang
Überschneidung	Vergleich erlaubter und tatsächlich geänderter Dateipfade
Vertrag	Festgelegte Funktionssignatur und Fehlerbehandlung
Übergabe	Commitkennung Testbefehl Testergebnis und Risiken
Konfliktlösung	Begründete verlustfreie Korrektur einer strittigen Änderung
Freigabeprüfung	Neue Tests am integrierten Stand und getrennte Zustimmung

Kreuzworträtsel

Die sechs Antworten bestehen jeweils aus genau einem Wort.

Orchestrator	Wer verteilt Aufträge und sammelt die Teilergebnisse?
Dateibesitz	Wie heißt die verbindliche Schreibzuständigkeit?
Mergekonflikt	Wie heißt ein Widerspruch beim Zusammenführen?
Übergabe	Was nennt man das geordnete Weiterreichen von Arbeitsresultaten?
Freigabe	Welche Entscheidung erlaubt eine geprüfte Integration?
Prüfsumme	Welcher berechnete Vergleichswert hilft bei der Identitätsprüfung von Daten?

LearningApps

Die Lernplattform kann ergänzende Zuordnungsübungen liefern. Der folgende Link ist eine Suche, keine Qualitätsprüfung vorhandener Treffer.

Offline-Alternative: Fünf Rollenkarten und fünf Rechtekarten auf Papier schreiben, mischen und die Zuordnung begründen.

Lückentext

Offene Aufgaben

Alle Aufgaben nutzen nur synthetische Daten, erlauben Papierlösungen und erfordern keine bezahlten Dienste.

Leicht

Softwareentwicklung: Zeichne ein Projekt mit Importdatei und zwei Testdateien und markiere die erlaubten Schreibzuständigkeiten.
Git: Erkläre Branch, Commit, Diff und Merge am Beispiel zweier unabhängiger Textänderungen.
Softwaretest: Notiere für fünf erfundene Messdatenzeilen die erwarteten Rückgaben oder Fehler von parse_zeile.
Teamarbeit: Erstelle eine Rollenkarte mit Agent A, B, C und der menschlichen Leitung einschließlich klarer Freigabegrenze.

Standard

Softwarearchitektur: Fertige einen Agentenplan mit Dateibesitz, Funktionsvertrag, Übergabeformat, Stoppregel und Freigabeschritt an.
Versionsverwaltung: Vergleiche zwei synthetische Dateilisten und identifiziere sowohl gemeinsame Schreibpfade als auch einen möglichen Schnittstellenkonflikt.
Python: Prüfe den Importcode und die fünf Tests mit einem lokalen Python-Interpreter oder simuliere jeden Test schriftlich und kennzeichne die Methode.
Code-Review: Verfasse einen unabhängigen Diff-Prüfbericht mit konkreten Befunden, Nachweisen und begründeter Annahme oder Ablehnung.

Schwer

Integrationstest: Erzeuge auf Papier einen semantischen Konflikt durch zwei unterschiedliche Funktionsnamen und konstruiere zwei Tests, die ihn zuverlässig entdecken.
Fehleranalyse: Bewerte den Konflikt NaN gegen 0.0, schütze beide Ausgangsversionen und begründe die fachlich richtige Korrektur.
Informationssicherheit: Ergänze einen Dokumentationsagenten mit minimalen Rechten und begründe den Umgang mit fremden Anweisungen in Quelldateien.
Projektmanagement: Vergleiche zentrale und Peer-Koordination, schätze den zusätzlichen Abstimmungsaufwand ab und verteidige eine Grenze sinnvoller Parallelität.

Lernkontrolle

Dateibesitz: Zwei Agenten melden eine Änderung an messdaten.py. Weise anhand der Rollenliste den Übergriff nach und begründe die nächste Maßnahme.
Mergekonflikt: Beschreibe schrittweise, wie zwei widersprüchliche Änderungsstände ohne Löschung der ursprünglichen Commits überprüfbar vereinigt werden.
Integrationstest: Begründe, weshalb erfolgreiche Einzeltests in Branch A nicht ausreichen und welche fünf Fälle nach dem Merge erneut geprüft werden.
Softwarearchitektur: Agent A benennt eine Funktion um, Agent B testet den alten Namen. Zeige den semantischen Fehler und einen passenden Nachweis.
Code-Review: Werte eine fiktive Pfadliste, ein Testprotokoll und den unabhängigen Bericht aus und entscheide mit drei Belegen über eine Freigabe.
IT-Sicherheit: Erläutere, warum eine Anweisung in einer fremden Datei keine Rechtevergabe auslösen darf, und formuliere eine Gegenregel.

Lernnachweis

Einzureichen: (1) Agentenplan mit Zuständigkeiten und Dateibesitz, (2) versionierter Schnittstellenvertrag, (3) zwei Übergabezettel mit Dateilisten und Risiken, (4) dokumentierter Konfliktentscheid, (5) fünf Testfälle mit echten Ergebnissen oder ehrlich markierter Papierprüfung, (6) unabhängiges Review und menschliche Freigabeentscheidung, (7) reflektierter Fehlerfall.

Kriterium	Erforderlicher Beleg	Gegenbeispiel
Überschneidung erkennen	gemeinsame Bearbeitungspfade und abweichende Verträge erkannt	nur allgemeine Warnung vor Teamarbeit
Konflikt ohne Verlust lösen	beide Versionen nachweisbar gesichert und erlaubte Regeln bewahrt	einen Branch ohne Vergleich löschen
Integration prüfen	Testfälle am zusammengeführten Commit und getrennte Reviewentscheidung	alte Erfolgsmeldung ohne Revisionsbezug

Selbstprüfung: Erkläre jede Entscheidung selbst, zeige den zugehörigen Nachweis und begründe einen Fall, der einen Merge verhindert. Hilfe: Lies die Schreibpfadtabelle und den Funktionsvertrag Zeile für Zeile. Vertiefung: Erweitere den Plan um begrenzte Eingabegrößen, eine prüfbare Vertragsversion und den Umgang mit einem falschen Reviewbericht.

OER und Wikipedia

Quellen- und Medienstand: 22.10.2026. Einzelne Online-Dokumentationen ändern sich laufend. Abrufbare Dateiseiten und Metadatentreffer sind keine Garantie dauerhafter Streaming-Verfügbarkeit.

Model Context Protocol – Security Best Practices – Dokumentationspfad 2026-07-28; minimale Scopes und Probleme bei Werkzeugberechtigungen.
NIST AI 600-1 – Generative AI Profile, Version Juli 2024; freiwilliger Risikomanagementrahmen, keine Zertifizierung.
Pro Git, 2. Ausgabe: Advanced Merging – Merge-Konflikte, Sicherung und Rücknahme.
GitHub: Geschützte Branches – laufend gepflegte Dokumentation zu Reviews und Pflichtprüfungen.
pytest-Dokumentation – zusätzliche Testoption, nicht für die Offline-Pflichtaufgaben erforderlich.
Microsoft Learn: Multiagenten-Orchestrierung – Vergleich zentraler und Peer-Modelle.
Genannter MOOCwiki-Grundlagenkurs – Link aus dem Auftrag; Inhalt beim Rechercheversuch nicht abrufbar und darum nicht unabhängig überprüft.
Wikipedia: Git – allgemeiner deutschsprachiger Überblick als Nachschlagewerk.

Geprüfte Commons-Mediendateien: Die unmittelbar zuvor eingefügten Medien haben Textalternativen und beschreibende Alternativtexte. Ihre öffentlich erreichbaren Dateiseiten nennen folgende Urheber und Lizenzen; es wurden keine eigenen Medien erstellt und keine Bilder verändert.

Dateiname und Vorschau	Echte Dateiseite	Urheber	Lizenz
	Commons	TheresNoTime	CC BY-SA 4.0
	Commons	Bunyk	CC BY-SA 4.0
	Commons	Bunyk	CC BY-SA 4.0
	Commons	Daniel Kinzler	CC BY 3.0
Video mit Ton und Bewegung	Commons-WebM	GitHub Original; Vbachem deutsche inoffizielle KI-Bearbeitung	CC BY 3.0

YouTube-Metadaten: Mit Mario, Lerne Git in 60 Minuten (deutsch, 2022) sowie Tech With Tim, Python-Tests mit pytest (englisch, 2025). Die Videos dienen nur als externe Vertiefung; künftige Verfügbarkeit und offene Wiederverwendung sind nicht garantiert. Die Textaufgaben funktionieren ohne sie.

Urheberrecht und Unabhängigkeit: CC-BY erfordert Urheber- und Lizenznennung, CC-BY-SA bei Bearbeitung zusätzliche Share-Alike-Bedingungen. Das Commons-Lehrvideo ist keine offizielle deutsche GitHub-Fassung. Dieses unabhängige Bildungsangebot ist keine offizielle Liebherr- oder IHK-Zertifizierung und keine Betriebs- oder Sicherheitsfreigabe.