Einsatz von Jira bei der agentenbasierten Entwicklung

Agentenbasierte Entwicklung wird von Jira unterstützt. Entwickler schreiben zunehmend nicht mehr selbst Code, sondern steuern KI-Agenten, die das Programmieren übernehmen. Das Aufgabenfeld verändert sich also. Schon jetzt verbringen Entwickler nur etwa 16 % ihrer Arbeitszeit mit dem Schreiben von Code. Je mehr davon auf Agenten verlagert wird, umso wichtiger werden die damit verbundenen Aufgaben: den Agenten Kontext zur Verfügung zu stellen, sie zu orchestrieren, ihre Ausgabe zu prüfen und sie zu kontrollieren.

Diese Aufgaben wurden schon immer in Jira verwaltet – sie dehnen sich jetzt nur auf Agenten aus. Jira und der Teamwork Graph sind dafür das maßgebliche System und die erforderliche Ebene, die KI-Aktivitäten in echte Produktivitätsgewinne verwandelt, wenn Teams skalieren.

In diesem Leitfaden erfährst du, wie Jira agentenbasierte Entwicklung unterstützt, wie es zu deinen anderen Tools passt und wie dir der Einstieg gelingt. Im Grunde leistet Jira drei Beiträge, die ein Programmierungsagent alleine nicht bieten kann:

• Es stellt Agenten den richtigen Kontext als Grundlage zur Verfügung, damit sie präzise handeln.

• Es delegiert Routineaufgaben an automatische, berechtigungsabhängige Flows.

• Es pflegt einen nachvollziehbaren Datensatz innerhalb des Teamwork Graph.

Was ist agentenbasierte Entwicklung?

Bei der agentenbasierten Entwicklung wird Software mithilfe von KI-Agenten erstellt. Diese planen anhand von Vorgaben mehrschrittige Abläufe und setzen sie um. Deine Aufgabe besteht also nicht mehr darin, jede Codezeile selbst zu schreiben, sondern die Ziele für die Agenten festzulegen und ihre Ergebnisse zu überprüfen.

Dadurch verlagert sich dein Aufgabenfeld vom eigentlichen Programmieren hin zum Entwerfen des Systems, in dem die Agenten arbeiten. Du legst fest, was erstellt werden soll, stellst den Agenten Kontext zur Verfügung, steuerst sie bei ihrer Arbeit und entscheidest, ob die Ausgabe den Anforderungen entspricht. Während eine KI-basierte automatische Vervollständigung nur die nächste Zeile vorschlägt, kann ein einzelner Agent ein beschriebenes Ergebnis bis hin zur Pull-Anfrage umsetzen. Agentenbasierte Entwicklung bewegt sich auf der Ebene darüber. Es geht darum, die verschiedenen Agenten skalierbar zu orchestrieren, ihre Aktionen zu koordinieren und zu steuern, was ausgeliefert wird.

Somit sind bei der agentenbasierten Entwicklung Koordination und Urteilsvermögen gefragt, nicht nur Programmierung. Wenn Agenten das Schreiben von Code übernehmen oder Aufgaben ausführen, müssen für ihren Zugriff, ihre Aktionen und ihre Ausgabe die Kontrollen gelten, die sich im Team bereits bewährt haben. Die Fragen, die dabei aufkommen, betreffen eher das Arbeitsmanagement als die Programmierung. Deshalb ist ein Datenbanksystem wie Jira unverzichtbar.

Ist Jira für agentenbasierte Entwicklung konzipiert?

Jira ist auf die KI-native Softwareentwicklung ausgelegt, bei der Vorgänge mit KI-Agenten geplant, orchestriert und skaliert werden. Bei der Frage nach der "Unterstützung" von agentenbasierter Entwicklung ist die eigentliche Frage eher, ob Jira als die Ebene fungieren kann, die den Kontext für die Arbeit der Agenten liefert und auf der die Agenten koordiniert, überprüft und gesteuert werden. Genau das kann Jira leisten – ein Programmierungsagent alleine dagegen nicht.

Ein Programmierungsagent schreibt die Änderung, kann aber nicht entscheiden, was entwickelt werden soll, beurteilen, ob das Ergebnis den Anforderungen entspricht, oder berücksichtigen, wie der Vorgang mit allen anderen zusammenhängt, die gerade in Bearbeitung sind. Diese Entscheidungen müssen im Rahmen des Arbeitsmanagements vom Team getroffen werden. Ein Programmierungsagent auf dem Computer eines einzelnen Mitarbeiters arbeitet nur für diesen. Wenn es um ein ganzes Team aus Mitarbeitern und Agenten geht, sind jedoch gemeinsame Koordination, Transparenz und eine zentrale Informationsquelle gefragt. Jira bildet diese Ebene: Es enthält den Plan, leitet einen Vorgang an den richtigen Agenten weiter, lässt Mitarbeitern die Kontrolle darüber, was veröffentlicht wird, und zeichnet auf, welche Aktionen erfolgt sind. All das steht dauerhaft als Kontext für künftige Vorgänge zur Verfügung. Die Schritte erfolgen in Jira ganz selbstverständlich und müssen nicht separat von einem Entwickler übernommen werden.

Welche Vorteile bietet Jira gegenüber einem einzelnen Programmierungsagenten?

Bei einem Programmierungsagenten besteht trotz Spezifikationen immer das Risiko von Abweichungen. Vielleicht vergisst er eine Entscheidung, wiederholt einen bereits abgeschlossenen Vorgang oder überschreitet die Grenzen seines Kontextfensters. Den Plan in einer Markdown-Datei zu speichern, behebt das Problem nicht. Auch ein besserer Agent ist nicht die Lösung. Die Lösung ist ein System, in dem die Spezifikation und der Status außerhalb der Erinnerung des Agenten gepflegt werden. In einem Team kommen so sehr viele Datensätze zusammen. Deshalb ist die Entscheidung für agentenbasierte Softwareentwicklung in Wirklichkeit eine Entscheidung für ein Datenbanksystem und nicht für ein bestimmtes Programmierungstool. Als solches System bietet Jira die unten genannten Funktionen.

Konnektoren verbinden deine Toolkette mit Teamwork Graph. MCP bringt das Wissen deiner Organisation in jede KI ein, die deine Teams bereits verwenden.

• Ein zentrales Datenbanksystem für die Arbeit von Mitarbeitern und Agenten: Agenten lesen und schreiben im Teamwork Graph und aktualisieren jede Entscheidung und jeden Eintrag rund um ihre Aufgabe, sodass Kontextinformationen nicht in lokalen Sitzungen verloren gehen.

• Governance gemäß den bereits vorhandenen Enterprise-Kontrollmechanismen: Der Zugriff der Agenten richtet sich nach dem im Unternehmen bereits bewährten Berechtigungsmodell. Diese Kontrollen werden automatisch auf die Arbeit der Agenten ausgeweitet. Die Governance für die Agenten läuft also nicht separat ab.

• Eine zentrale Oberfläche für alle Agenten und Modelle: Du kannst Vorgänge Claude, Cursor, Codex, GitHub Copilot oder dem nativen Jira-Programmierungsagenten zuweisen und sie zentral orchestrieren. Da die Agenten innerhalb deiner vorhandenen Workflows arbeiten, ändert sich dein Prozess nicht, selbst wenn sich die Agenten ändern. Bei einem einzelnen Programmierungsagenten bist du an einen bestimmten Anbieter gebunden, Jira dagegen funktioniert unabhängig von den Agenten.

• Kontextbasierte Entwicklung aus dem gesamten Stack, nicht nur aus dem Ticket. Der Teamwork Graph verankert Agenten in den Vorgängen, Entscheidungen und dem Verlauf über Jira, Confluence, Code und die Tools hinweg, in denen die Vorgänge tatsächlich besprochen werden, wie Slack und Teams. So handeln Agenten auf Grundlage echter Absichten und nicht auf Basis eines leeren Prompts. Damit wird Jira zur Kontextebene rund um den Agenten.

• Du erhältst eine zentrale Steuerungsebene für die Agentenvorgänge. Ein Coding-Agent läuft in seiner eigenen Sitzung, getrennt vom Plan und der anderen Arbeit des Teams. Jira fügt diese Ebene hinzu, um zu entscheiden, was Agenten übernehmen, ihnen den richtigen Kontext zu geben und jede Coding-Sitzung wieder mit dem Vorgang zu verknüpfen, der sie liefert. Den Entwicklern entsteht keine zusätzliche Arbeit. Während das Datenbanksystem das Geschehene erfasst, steuerst und verbindest du über die Steuerungsebene die Agentenvorgänge im Hintergrund.

Wo Jira in den KI-nativen Softwareentwicklungslebenszyklus passt

Jira unterstützt Agentenvorgänge in vier Phasen: planen, orchestrieren, überprüfen und skalieren. Du planst den Vorgang in agentenbereite Elemente, orchestrierst Agenten, damit sie ihn ausführen, prüfst und testest, was sie erstellen, und skalierst diese Muster in der gesamten Organisation mit den Governance-Regeln und Berechtigungen, die für ihre Sicherheit sorgen. Hier erfährst du, was Jira bei jedem Schritt macht.

Planen: Wie werden Vorgänge agentenfähig gemacht?

Erstelle aus Plänen und Dokumentation mit einem Klick vorgeschlagene Vorgänge, überprüfe diese und passe sie bei Bedarf an, bevor du sie übernimmst.

Die Planung ist der Punkt, an dem du eine Absicht in einen agententauglichen Vorgang verwandelst: eine tatsächliche Spezifikation mit klaren Anforderungen und Akzeptanzkriterien sowie dem Kontext, den der Agent vor dem Start braucht.

• Erfasse den Vorgang dort, wo er beginnt. Anfragen entstehen überall: aus einem Slack-Thread, einer Confluence-Seite, einer Loom-Aufzeichnung, einem Meeting. Erwähne @Jira oder nutze Rovo, um Anfragen an Ort und Stelle in Vorgänge umzuwandeln. Das Erfassen spart mehr als erneutes Tippen: Es verwandelt eine vage Anfrage, auch wenn sie als Konversation begonnen hat, in einen Vorgang mit Kontext aus dem Teamwork Graph dazu, wie er in den Vorgang des Teams passt.

• Gib dem Agenten eine klar definierte Spezifikation und nicht nur einen Prompt. Bei der spezifikationsgesteuerten Entwicklung ist die Spezifikation die verankernde Eingabe: Der Agent arbeitet am Vorgang auf Grundlage der Spezifikation, nicht auf Grundlage eines einmaligen Prompts, der nach der Sitzung verloren geht. Diese Spezifikation arbeitet zusammen mit der Codebasis, den Teamstandards und dem Projektverlauf, sodass der Agent den nötigen Kontext hat, um Code zu entwerfen, der zu deinen Teamstandards passt. Jira Planner erstellt mithilfe von Teamwork Graph, deiner Codebasis und dem Verlauf einen Spezifikationsentwurf in Confluence. Anschließend verfeinerst du ihn und fügst Akzeptanzkriterien hinzu. So bildet die Spezifikation die Grundlage für die Entwicklung und Überprüfung des Agenten.

• Gib Agenten Kontext, der sich kumuliert. Kontext ist die eigentliche Einschränkung für die Qualität von Agenten. Jira greift auf den Teamwork Graph zu, um Agenten in den Zielen, Entscheidungen und dem Verlauf all deiner Tools zu verankern, nicht nur im Ticket. Es funktioniert mit jedem MCP-Agenten, und dieser Kontext kumuliert sich: Je mehr Vorgänge durch das System laufen, desto mehr steht den Agenten zur Verfügung, und die Ergebnisse werden immer besser.

Orchestrieren: Wie werden Vorgänge Agenten zugewiesen und an sie geleitet?

Weise Vorgänge Agenten zu, einschließlich des nativen Jira Coding Agent, und das alles an einem Ort.

Weise den Vorgang dem Agenten zu, der dafür am besten geeignet ist. Steuere und überwache dann, was diese Agenten tun – alles an dem Ort, an dem dein Team seine Vorgänge bereits nachverfolgt.

• Weise jeden Vorgang einem beliebigen Agenten zu – alles an einem Ort. Weise Claude, Cursor, Codex, GitHub Copilot oder dem nativen Jira Coding Agent einen Vorgang zu und sieh dir dann an, welche Aktionen er ausgeführt und welche Entscheidungen er in Web-, IDE- und Terminal-Sitzungen getroffen hat. So kannst du Abweichungen frühzeitig erkennen und korrigieren, ohne den Flow zu unterbrechen.

• Triff Agenten dort, wo du bereits arbeitest. Orchestriere auf den Oberflächen, die dein Team nutzt: Erwähne @Jira in Slack, um einen Vorgang zu erstellen und einen Korrekturzyklus zu starten. Verbinde Cursor, Claude Desktop oder einen beliebigen MCP-Client mit dem Kontext von Jira oder gib Agenten CLI-/Terminalzugriff, um vom Kontext zur Aktion zu wechseln.

• Automatisiere Routinevorgänge. Löse einen Agenten über eine Automatisierungsregel oder einen Workflow-Übergang aus (oder füge einen Agenten zu einer Board-Spalte hinzu), damit er Vorgänge bei Statusänderungen automatisch erfasst und die Ausgabe über denselben Workflow zurückleitet. Am besten fängst du mit routinemäßigen, sich wiederholenden Vorgängen an.

• Die Aktivität von Agenten bleibt sichtbar und mit dem Vorgang verknüpft. Während ein Agent arbeitet, bleiben seine Aktivität und die Pull-Anfrage, die er öffnet, mit dem Vorgang verknüpft. Der Fortschritt ist dort sichtbar, wo der Vorgang stattfindet, und versteckt sich nicht in einem separaten Tool. Du siehst, was jeder Agent übernommen hat, was er erstellt hat und was auf eine Überprüfung wartet – alles an einem Ort.

Überprüfung: Wie wird die Ausgabe eines Agenten validiert?

Die Ausgabe der Agenten-sollte immer durch einen menschlichen Partner überprüft werden (Human-in-the-Loop).

Die Ausgabe eines Agenten kann fertig aussehen und trotzdem falsch sein. Daher sollte sie nicht ausgeliefert werden, bis sie geprüft, getestet und freigegeben wurde.

• Testen und Validieren. Die Ausgabe eines Agenten muss weiterhin die üblichen Checks durchlaufen. Diese Überprüfungen finden in deiner CI-Pipeline statt und ihr Status wird im Vorgang angezeigt, damit ein Prüfschritt den Übergang zu Erledigt stoppen kann, bis der Vorgang verifiziert wurde. Du kannst einen Teil davon automatisieren: Ein Agent prüft seine eigene Ausgabe und iteriert so lange weiter, bis die Überprüfung erfolgreich ist, bevor sie eine Person erreicht.

• Prüfung mit menschlicher Beteiligung, direkt in deinen Workflow integriert. Mache eine von Menschen geleitete Überprüfung erforderlich: Die Ausgabe wird im Vorgang angezeigt und kann erst zu "Erledigt" übergehen, wenn jemand sie genehmigt. Die Pull-Anfrage und ihr Prüfstatus werden im Entwicklerbereich des Vorgangs angezeigt, sodass die Überprüfung dort erfolgt, wo sie nachverfolgt wird.

• Führe Merges durch und zeichne auf, was ausgeliefert wurde. Sobald die Überprüfung erfolgreich war, wird die Änderung in einem Merge zusammengeführt und der Vorgang in "Erledigt" verschoben. Merging und Bereitstellung erfolgen in deinen verbundenen Tools; Jira zeichnet den Nachweis auf.

Skalierung: Wie werden Agenten über einen längeren Zeitraum sicher über mehrere Teams hinweg betrieben?

Ein gemeinsames System of Work erhöht die Erfolgschancen der Skalierung im Unternehmen.

Das Skalieren von Agenten ist eine Veränderung auf Organisationsebene. Die Herausforderung besteht weniger darin, dass einzelne Entwickler mehr Agenten ausführen, sondern vielmehr darin, Qualität, Vertrauen und Transparenz konstant zu halten, während sich Agentenvorgänge teamübergreifend ausbreiten.

• Delegiere die Routineaufgaben. Agenten übernehmen wiederkehrende, klar definierte Vorgänge im Hintergrund, Pull-Anfragen werden angezeigt, wenn sie bereit sind, und du behältst durch gemeinsame Berechtigungen und Sicherheitsstandards die Kontrolle.

• Iteriere. Agentenbasierte Entwicklung ist ein Kreislauf, keine Linie: Ergebnisse fließen in die nächste Spezifikation zurück und Vorgänge treten wieder in den Lebenszyklus ein. Jira ist der Ort, an dem dieses Feedback erfasst wird, damit zukünftige Vorgänge weiter verfeinert werden können.

• Verwalte und überprüfe. Guardrails sind im Workflow integriert, nicht in einem Richtliniendokument. Jede Aktion hinterlässt eine prüfbare Spur im Vorgang, gesteuert durch Jiras eigene Berechtigungen.

• Miss die Wirkung. Verfolge, wie KI die Art und Weise verändert, wie dein Team liefert, indem du Lieferdaten wie Durchlaufzeit und Pull-Anfragen-Durchsatz nutzt, damit du Ergebnisse statt Aktivitäten messen und dort investieren kannst, wo es zählt.

Wie passt Jira zum Rest deines KI-Stacks?

Jira ersetzt weder deine Coding-Agenten noch deine IDE oder die Modelle, die du ausführst. Es ist die Koordinations- und Protokollierungsebene, die über ihnen liegt, damit Vorgänge sichtbar bleiben und gesteuert werden, ganz gleich, mit welchen Tools die Umsetzung erfolgt. Diese Ebene ist beim Skalieren nicht optional; ohne ein gemeinsames führendes System wird die Arbeit von Agenten auf Tools fragmentiert, und die Produktivität kann sich nicht vollständig entfalten.

Erste Schritte mit der agentenbasierten Entwicklung in Jira

Schau dir die Aktionen an, die deine Agenten ausgeführt haben, und die Entscheidungen, die sie getroffen haben. Überprüfe den kompletten Sitzungsverlauf, erkenne Abweichungen frühzeitig und korrigiere sie bei Bedarf.

Du brauchst keinen vollständigen Rollout, um loszulegen. Der schnellste erste Erfolg ist das Verbinden eines Coding-Agenten, ihm eine kleine Aufgabe zuzuweisen und die Pull-Anfrage zu prüfen, die er öffnet – alles aus einem einzigen Vorgang heraus.

1. Wähle eine einzelne Routineaufgabe mit klarem Umfang aus. Ein instabiler Test, ein Problem mit einer Abhängigkeit oder eine kleine Fehlerbehebung ist der sicherste Einstiegspunkt.

2. Erfasse diese Aufgabe als Vorgang. Wandle eine Confluence-Seite, einen Slack-Thread oder einen kurzen Prompt in einen Vorgang mit Zusammenfassung und Beschreibung um.

3. Weise den Vorgang einem Agenten zu. Binde dein Git-Repository ein und weise dann im Bereich für Agenten den Vorgang dem Jira-Programmierungsagenten zu.

4. Überprüfe die Pull-Anfrage. Der Agent öffnet eine Pull-Anfrage, die mit dem Vorgang verknüpft ist, damit du sie dort prüfen kannst, wo du sie auch geplant hast.

5. Automatisiere die Aufgabe. Suche nach diesem ersten Durchlauf nach Aufgaben, die immer wieder anfallen, und erstelle Automatisierungsregeln dafür. Die Automatisierung von Routineaufgaben ist ein guter Einstieg, da sie den größten Nutzen und das geringste Risiko bietet.

Du möchtest noch schneller loslegen? Die Vorlage für agentenbasierte Entwicklung musst du nur einmal konfigurieren, damit sie automatisch einen für Agenten bereiten Bereich mit den erforderlichen Workflows, Status und Agentenschritten erstellt. So kannst du mit einem funktionierenden Ablauf statt mit einem leeren Projekt starten. Du nutzt in einem Bereich bereits agentenbasierte Workflows, die gut funktionieren? Kunden mit einem kostenpflichtigen Tarif können sie als benutzerdefinierte Vorlage speichern, damit dein Team neue Bereiche mit denselben integrierten Agenten und demselben Workflow erstellen kann.

Häufig gestellte Fragen zur agentenbasierten Entwicklung

Wie sieht die Rolle von Entwicklern bei der agentenbasierten Entwicklung aus?

Bei der agentenbasierten Entwicklung definiert ein Entwickler die Ziele, den Kontext und die Guardrails, die KI-Agenten durch mehrstufige Vorgänge leiten, und prüft und genehmigt dann die Ergebnisse. Die Koordinierung erfolgt in einem Datensatzsystem wie Jira, damit alles nachvollziehbar bleibt.

Was ist der Unterschied zwischen Prompt Engineering und agentenbasierter Entwicklung?

Beim Prompt Engineering wird eine einzelne Anweisung für eine gute Modellantwort generiert. Bei der agentenbasierten Entwicklung werden Agenten koordiniert, die über eine gesamte Aufgabe hinweg planen, handeln und iterieren. Die konkrete Aufgabe verschiebt sich vom Prompt auf das Ziel.

Welche Vorteile bietet Jira gegenüber einem einzelnen Programmierungsagenten?

Ein Programmierungsagent schreibt Code, aber in Jira werden die Vorgänge definiert, priorisiert, orchestriert, geprüft und in einem gemeinsamen Datensatzsystem verwaltet. Es sorgt für die Koordinierung der Agenten und pflegt zu jedem Vorgang einen Audit-Trail.

Wie beziehen KI-Agenten Kontextinformationen aus Jira?

Agenten beziehen Kontextinformationen aus dem Vorgang selbst (Anforderungen und Akzeptanzkriterien) und aus dem Teamwork Graph, der zusammengehörige Vorgänge, Dokumente und Code miteinander verknüpft. So hat der Agent nicht nur den Prompt zur Verfügung, sondern kann sich bei Aktionen auf eine solide Grundlage stützen.

Wird Jira noch benötigt, wenn die KI den Code schreibt?

Ja, und vermutlich sogar in größerem Umfang als bisher: Da Agenten in kürzerer Zeit mehr Code generieren, verlagert sich der potenzielle Engpass auf die Koordination, Überprüfung und Steuerung dieser Vorgänge. Jira ist die Kontrollebene, die dafür sorgt, dass die Ausgabe der Agenten transparent, nachvollziehbar und mit dem Vorgang verknüpft bleibt, für den sie gedacht war.