Wer schreibt den Code, wenn Agenten sich dem Workflow anschließen?

KI-basierte Programmierwerkzeuge beschränken sich nicht mehr nur auf Autocomplete-Funktionen. Sie umfassen reaktive Partner-Programmierer, Aufgabenerben, die Tickets ausführen, autonome Projektagenten, die eigene Branches verwalten, sowie experimentelle Schwärme, in denen mehrere Agenten einander kritisieren und Korrekturen vornehmen. Die wichtige Frage ist nicht, welche Marke man installieren soll, sondern welche Stufe zum Risiko der vorgenommenen Änderung passt.

Von Autocomplete zur Autonomie

Frühe Assistenten vervollständigten die Zeile unter dem Cursor. Neuere Agenten öffnen Dateien, führen Tests durch und erstellen Pull-Requests. Mit zunehmender Autonomie steigt auch der „Blastradius“ – daher sollten die Überprüfungsintensität, das Sandbox-Verfahren sowie Klarheit der gestellten Ziele zunehmen.

Ebene 1 – KI-basierte Partner-Programmierer

Reaktives Autocomplete sowie Chat-Funktionen innerhalb der IDE. Man steuert jeden Commit selbst. Am besten geeignet für Standardcode, Umbenennungen sowie die Erklärung unbekannten Codes. Schwach bei Refaktorisierungen mehrerer Dateien ohne Anleitung.

# Conceptual representation of a Tier 3 agent's execution loop
def execute_project_goal(goal: str):
    plan = agent.generate_plan(goal)
    while not plan.is_complete():
        action = plan.get_next_action()
        result = workspace.run(action)      # Runs commands, edits files
        if result.has_errors():
            plan.replan(result.logs)       # Self-correction loop
        else:
            plan.mark_step_done()

Ebene 2 – auf Aufgaben zugeschnittene Agenten

Zielorientierte Ausführende: „Fügen Sie Protokollierung zu diesem Handler hinzu“, „Schreiben Sie Tests für dieses Modul.“ Sie planen kurze Tool-Zyklen und stoppen, sobald die Zielprüfung erfolgreich ist. Dennoch ist eine menschliche Überprüfung für den Merge erforderlich.

import time
from typing import Dict, Any

def run_agent_loop(task_prompt: str, max_iterations: int = 15) -> bool:
    # Initialize the agent's state, workspace, and execution context
    state: Dict[str, Any] = {
        "task": task_prompt,
        "workspace_files": get_project_files(),
        "history": [],
        "completed": False
    }

    for step in range(max_iterations):
        # 1. Perception: Observe current system state and tool outputs
        observation = observe_environment(state)

        # 2. Planning: Reason through the current state to generate a thought and next action
        thought, action = LLM_reasoning_engine(state, observation)
        state["history"].append({"step": step, "thought": thought, "action": action})

        if action.name == "task_complete":
            print(f"Task successfully completed in {step} steps.")
            return True

        # 3. Action: Execute the tool and capture the side effects
        try:
            action_result = execute_action(action)
            state = update_state(state, action_result)
        except Exception as execution_error:
            # Feed the error back to the LLM to allow for self-correction
            state = update_state(state, {"error": str(execution_error)})

        time.sleep(1) # Implement rate limiting and token management

    print("Agent failed: Reached maximum iteration budget.")
    return False

Ebene 3 – autonome Projektagenten

End-to-End-Ingenieure für ein definiertes Projekt: Aufbau, Implementierung, Testen, Iterieren. Sie benötigen klare Akzeptanztests sowie eine abgeschottete Umgebung. Ohne Tests geraten sie in Verwirrung.

import subprocess
import json
import sys

def execute_agentic_workflow(specification_path: str) -> bool:
    """
    Orchestrates an agent by feeding it a structured specification,
    applying the generated code changes, and running unit tests to verify correctness.
    """
    # Step 1: Load the structured technical specification
    with open(specification_path, "r") as f:
        spec = json.load(f)

    print(f"🤖 Agent starting task: {spec['task_id']} - {spec['description']}")

    # Step 2: Agent generates code based on spec (simulated here)
    generated_code_diff = simulate_agent_generation(spec)

    # Step 3: Apply the generated patches to the codebase
    if not apply_patch(generated_code_diff):
        print("❌ Critical: Agent-generated patch failed to apply cleanly.")
        return False

    # Step 4: Run automated validation suites
    print("🧪 Running verification test suite...")
    test_result = subprocess.run(["pytest", "tests/test_agent_features.py"], capture_output=True, text=True)

    if test_result.returncode == 0:
        print("✅ Success: Agent changes verified successfully.")
        return True
    else:
        print("❌ Failure: Automated tests failed. Raw stderr output:")
        print(test_result.stderr)
        return False

def simulate_agent_generation(spec: dict) -> str:
    # Simulates returning a git patch block matching the spec constraints
    return "diff --git a/app.py b/app.py..."

def apply_patch(diff: str) -> bool:
    # Logic to apply git patch
    return True

if __name__ == "__main__":
    execute_agentic_workflow("specs/new_feature_spec.json")

Ebene 4 – agierende Schwärme

Kollaborative Multi-Agenten-Netzwerke: Forscher, Implementierer, Prüfer. Leistungsstark, aber teuer. Koordinationsfehler werden zum neuen Versagen.

+----------------+      +-----------------+      +-----------------+      +-----------------+
|     Define     | ---> |     Prompt      | ---> |      Test       | ---> |     Verify      |
|  (Requirements |      | (Context, Specs |      |   (Automated    |      | (Human Approves |
|  & Interfaces) |      |   & Constraints)|      |  Suites & Runs) |      |   Final Diffs)  |
+----------------+      +-----------------+      +-----------------+      +-----------------+

Anatomie eines Programmieragenten

Wahrnehmung (Repo-Tools), Planung (Aufteilung der Aufgaben), Handlung (Änderungen/Befehle) sowie Speicher (Notizbücher, PR-Kontext). Fehlt eines davon, bricht die Ebene zusammen.

Generated by AI Agent: Provisions a secure, auto-scaling AWS ECS Fargate service
resource "aws_ecs_task_definition" "app" {
  family                   = "production-api"
  requires_compatibilities = ["FARGATE"]
  network_mode             = "awsvpc"
  cpu                      = "256"
  memory                   = "512"

  container_definitions = jsonencode([{
    name      = "api-service"
    image     = "backend-service:latest"
    essential = true
    portMappings = [{
      containerPort = 8080
      hostPort      = 8080
    }]
  }])
}

Wahl der Ebene

Passen Sie die Ebene dem Kritikalitätsgrad des Repositoriums, der Stärke der Tests sowie der Umkehrbarkeit der Änderung an. Verwenden Sie vorerst Ebenen 1–2 in den Zahlungsabläufen, bis geeignete Bewertungstools verfügbar sind. Nutzen Sie Ebene 3, wenn die CI-Prüfungen streng sind und der Sandbox keinen Zugriff auf Produktionsgeheimnisse hat.

# safe_executor.py
import ast

# An allowlist of pre-approved libraries prevents hallucinated dependency injection.
ALLOWED_PACKAGES = {"requests", "pandas", "numpy", "json", "pydantic"}

def verify_agent_imports(agent_code: str) -> bool:
    """Parses agent code into an AST to audit imports before execution."""
    try:
        tree = ast.parse(agent_code)
        for node in ast.walk(tree):
            if isinstance(node, ast.Import):
                for alias in node.names:
                    base_package = alias.name.split('.')[0]
                    if base_package not in ALLOWED_PACKAGES:
                        raise SecurityError(f"Blocked unapproved import: {alias.name}")
            elif isinstance(node, ast.ImportFrom) and node.module:
                base_package = node.module.split('.')[0]
                if base_package not in ALLOWED_PACKAGES:
                    raise SecurityError(f"Blocked unapproved import from: {node.module}")
        return True
    except (SyntaxError, SecurityError) as e:
        print(f"Safety Gate Tripped: {e}")
        return False

class SecurityError(Exception):
    pass

# Example of agent output containing a hallucinated or malicious library.
untrusted_code = "import requests\nimport fast_json_validator_fake_pkg"
is_safe = verify_agent_imports(untrusted_code)
print(f"Is code safe to execute? {is_safe}") # Prints: Is code safe to execute? False

Arbeitsablaufgewohnheiten, die sicherstellen, dass Menschen die Kontrolle behalten

Schreiben Sie Akzeptanzprüfungen vor dem Aufruf eines Agents. Erfordern Sie Differenzen in überprüfbaren Abschnitten. Protokollieren Sie jeden Toolaufruf. Verbieten Sie uneingeschränkten Shell-Zugriff auf sensible Hosts. Betrachten Sie die Geschwindigkeit der Agents als Risikometer, wenn die Defektraten steigen.

Die Zukunft davon, wer Code schreibt, liegt in der gemeinsamen Autorenschaft mit expliziten Kontrollmechanismen – nicht in unüberwachten Commit-Zeitpunkten in den Hauptcode. Halten Sie die Tests in einem funktionierenden Zustand, messen Sie jede Phase getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin etwas zu veröffentlichen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen könnte. Halten Sie die Tests in einem funktionierenden Zustand, messen Sie jede Phase getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin etwas zu veröffentlichen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen könnte. Halten Sie die Tests in einem funktionierenden Zustand, messen Sie jede Phase getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin etwas zu veröffentlichen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen könnte. Halten Sie die Tests in einem funktionierenden Zustand, messen Sie jede Phase getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin etwas zu veröffentlichen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen könnte. Halten Sie die Tests in einem funktionierenden Zustand, messen Sie jede Phase getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin etwas zu veröffentlichen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen könnte. Halten Sie die Tests in einem funktionierenden Zustand, messen Sie jede Phase getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin etwas zu veröffentlichen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen könnte.

Man kann denselben stillen Fehlermodus unter einem neuen Namen wieder einführen. Halten Sie die Geräte in Ordnung, messen Sie jede Stufe getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin zu versenden, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann. Halten Sie die Geräte in Ordnung, messen Sie jede Stufe getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin zu versenden, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann. Halten Sie die Geräte in Ordnung, messen Sie jede Stufe getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin zu versenden, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann. Halten Sie die Geräte in Ordnung, messen Sie jede Stufe getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin zu versenden, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann. Halten Sie die Geräte in Ordnung, messen Sie jede Stufe getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin zu versenden, wenn die nächste Version denselben stillen Fehler mOde unter einem neuen Namen. Halten Sie die Einrichtungen grün, messen Sie jede Stufe getrennt voneinander und weigern Sie sich, allein auf Intuitionen zu vertrauen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann. Halten Sie die Einrichtungen grün, messen Sie jede Stufe getrennt voneinander und weigern Sie sich, allein auf Intuitionen zu vertrauen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann. Halten Sie die Einrichtungen grün, messen Sie jede Stufe getrennt voneinander und weigern Sie sich, allein auf Intuitionen zu vertrauen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann. Halten Sie die Einrichtungen grün, messen Sie jede Stufe getrennt voneinander und weigern Sie sich, allein auf Intuitionen zu vertrauen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann. Halten Sie die Einrichtungen grün, messen Sie jede Stufe getrennt voneinander und weigern Sie sich, allein auf Intuitionen zu vertrauen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann. Halten Sie die Einrichtungen grün, meBehalten Sie die Prüfgeräte in gutem Zustand, messen Sie jede Stufe getrennt voneinander und weigern Sie sich, allein auf Intuitionen zu vertrauen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann.Halten Sie die Ausrüstungen in einem guten Zustand, messen Sie jede Phase getrennt voneinander und weigern Sie sich, allein auf Intuitionen zu vertrauen beim Versand, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen könnte.Führen Sie denselben stillen Fehlermodus unter einem neuen Namen ein. Halten Sie die Testumgebungen intakt, messen Sie jede Phase getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin zu veröffentlichen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann. Halten Sie die Testumgebungen intakt, messen Sie jede Phase getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin zu veröffentlichen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann. Halten Sie die Testumgebungen intakt, messen Sie jede Phase getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin zu veröffentlichen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann. Halten Sie die Testumgebungen intakt, messen Sie jede Phase getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin zu veröffentlichen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann. Halten Sie die Testumgebungen intakt, messen Sie jede Phase getrennt voneinander und weigern Sie sich, allein auf Intuitionen hin zu veröffentlichen, wenn die nächste Version denselben stillen Fehlermodus untereinen neuen Namen.Überprüfen Sie jede Stufe getrennt und weigern Sie sich, allein auf Intuitionen zu vertrauen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann. Halten Sie die Ausrüstung in Ordnung, messen Sie jede Stufe separat und weigern Sie sich, allein auf Intuitionen zu vertrauen, wenn die nächste Version denselben stillen Fehlermodus unter einem neuen Namen wieder einführen kann.