Loop engineering in Jira

De meeste teams gebruiken AI-codeeragents interactief: prompt, wachten op uitvoer, beoordelen en herhalen. Loop engineering verplaatst die uitvoering naar achtergrond-cloudagents die asynchroon werken. In plaats van de terminal van een developer te bezet te houden, handelt de agent zelfstandig run-the-business-taken af.
Achtergrondagents werken alleen wanneer de status behouden blijft tussen uitvoeringen. Omdat modellen geen geheugen hebben tussen sessies, heeft de lus een registratiesysteem nodig om voortgang bij te houden, pass/fail-controles te evalueren en werk over te dragen. Die status kan het werk zijn dat de agent al heeft geproduceerd. Daardoor gaat de echte vraag minder over de agent en meer over waar het werk zich bevindt, wat direct wijst naar je registratiesysteem. In Jira bestaat dat systeem al.
In deze gids wordt het volgende behandeld:
Wat loop engineering is en hoe het verschilt van prompt engineering
De onderdelen van een agent draaien in een lus, van werk vinden tot beslissen wat de volgende stap is
Een agentlus uitvoeren in Jira, waar je werk al staat
Wat is loop engineering?
Begin met de loop zelf. Een lus is de cyclus die een agent zelfstandig herhaalt en die doorgaat totdat de agent een doel bereikt of een limiet bereikt. Loop-engineering is de praktijk van het bouwen en beheren van die lus, de trigger en de voorwaarden om af te sluiten. Je stelt het doel in en bouwt de cyclus. Daarna pakt de agent het werk op, onderneemt actie, controleert het resultaat en beslist wat daarna moet gebeuren.
Elke werklus combineert twee dingen. Het eerste is een cyclus die dezelfde vier stappen herhaalt: vinden, handelen, controleren en beslissen. Het tweede is een duurzame registratie van wat er is gebeurd, omdat het model niets bewaart tussen uitvoeringen. Elke uitvoering schrijft de status naar die registratie en de volgende uitvoering leest die weer terug als context. Dat betekent dat elke ronde begint met de informatie van de vorige in plaats van met een blanco begin. Waar die registratie is bepaalt of een lus verder kan gaan waar die is gestopt. Hoe de lus ook begint, of je die nu opnieuw uitvoert of een planning die activeert, de cyclus zelf blijft hetzelfde.
Loop engineering versus prompt engineering
Prompt engineering en loop engineering zijn geen concurrenten. Ze werken op verschillende niveaus. Prompt engineering bepaalt wat een agent in één beurt doet. Loop engineering bepaalt het systeem dat veel beurten uitvoert om een doel te bereiken. Je schrijft nog steeds goede prompts binnen een lus, maar de lus beslist wanneer die worden uitgevoerd, controleert de resultaten en gaat door.
Het verschil zit in wie het werk doet tussen de beurten door. Bij prompt-engineering zit jij op de stoel. Je stuurt een instructie, leest het antwoord en beslist zelf wat de volgende stap is. Bij loop-engineering houdt het systeem de stoel vast. Het houdt de agent actief, evalueert elk resultaat en betrekt je alleen wanneer er een beslissing nodig is.
Prompt engineering | Loop engineering | |
|---|---|---|
Wat je ontwerpt | Een enkele instructie | De cyclus die veel instructies uitvoert |
Wie het resultaat beoordeelt | Jij, elke keer | De lus, dan jij wanneer het ertoe doet |
Meest geschikt voor: | Eenmalige taken en snelle antwoorden | Doorlopend, herhaalbaar werk om een doel te bereiken |
Wat het nodig heeft om te werken | Een duidelijke prompt | Een trigger, een controle en een plek om de status te registreren |
Het harnas is de omgeving waarin één agent draait, terwijl de lus de cyclus is die agents steeds naar werk blijft verwijzen. Zie context engineering voor informatie over hoe je één agent de juiste input geeft.
Wat zijn de onderdelen van een agentlus?
1. Ontdekking: hoe een lus wordt geactiveerd
Elke lus heeft een trigger nodig. De eenvoudigste is dat iemand de agent opnieuw uitvoert totdat het werk klaar is. Slimmere triggers nemen die afhankelijkheid weg, zoals een planning, een gebeurtenis of een wachtrij met open items die elke uitvoering start, zodat de lus doorgaat zonder dat je hoeft te volgen.
2. Actie: de agent doet het werk waarvoor hij verantwoordelijk is
De agent voert de stap uit die hij mag beheren, en niets dat breder gaat. De scope is wat een lus veilig maakt om zonder toezicht uit te voeren.
3. Controle: de lus beoordeelt zijn eigen uitvoer
De lus controleert zijn eigen uitvoer voordat hij doorgaat, meestal door de tests of de build uit te voeren. Als de controle mislukt, probeert de lus het opnieuw of stopt hij in plaats van verder te gaan. Een lus zonder deze stap produceert meer uitvoer, geen betere uitvoer.
4. Registreren: de lus schrijft op wat er is gebeurd
Na elke uitvoering schrijft de lus de status weg naar een duurzame opslaglocatie: wat de lus heeft gedaan, wat er nog over is en wat is mislukt. Dit is het onderdeel dat de meeste zelfgebouwde lussen verkeerd doen, en de reden waarom een gedeeld registratiesysteem belangrijk is.
5. Beslis wat de volgende stap is: itereren, afronden of overdragen
De lus leest de eigen registratie en routeert het werk. De lus wordt opnieuw uitgevoerd, sluit het werk of draagt het over aan een persoon wanneer de lus het niet zeker weet of buiten de grenzen valt. Escalatie is de uitgang en patronen voor human-in-the-loop beschrijft hoe die overdracht werkt.
Hoe Jira een agentlus uitvoert en onthoudt
Een lus heeft een duurzame registratie en een plek nodig om vanaf te triggeren, en beide bestaan al op de plek waar je team werk uitvoert. In Jira is het werkitem het record dat tussen runs blijft bestaan, en automatiseringsregels zijn de trigger die van een taak een lus maakt. Je hergebruikt de toegangsregels en geschiedenis waar je team al op vertrouwt, in plaats van daarnaast een apart systeem te hebben.
Elk deel van de lus komt overeen met iets wat Jira al doet.
Lusonderdeel | Hoe Jira het doet |
|---|---|
Discovery | Een automatiseringsregel vindt open werk in een planning of een event |
Actie | Je wijst het werkitem toe aan een codeeragent, zoals de Jira-codeeragent |
Controleer | Tests slagen of de build is geslaagd |
Overdracht | De agent opent een pull request |
Gegevens | Het werkitem en de weergave van agentsessies op de Voor jou-pagina in Jira bevatten wat er is gebeurd |
Bepaal wat de volgende stap is | Automatisering stuurt de uitkomst door, of draagt over aan een persoon |
Twee dingen brengen het samen. Het werkitem bevat de status, en de Teamwork Graph zet die om in de context die de volgende run leest. Het verbindt het item met de code, beslissingen en documentatie eromheen. Wanneer een run een persoon nodig heeft, volgt die overdracht human-in-the-loop-patronen. De registratie zelf is het voordeel ten opzichte van een zelfgeschreven script, omdat hij wordt gedeeld, met toegangsrechten is beveiligd en wordt ondersteund door audittrails. Mensen en agents werken vanuit één registratiesysteem, niet twee.
Je eerste agentlus bouwen in Jira
Je hoeft niet opnieuw te ontwerpen om te beginnen. Kies één terugkerende taak, geef die een trigger en een plek om de status te registreren, en voer de lus eerst uit op omkeerbaar werk. Dit is de volgorde die werkt.
1. Kies een terugkerende taak met weinig risico
Kies voorspelbare taken waarbij de criteria objectief zijn en wijzigingen eenvoudig te verifiëren zijn, zoals het bijwerken van afhankelijkheden, het patchen van beveiligingskwetsbaarheden of het oplossen van schendingen van toegankelijkheid. Door routineonderhoud door een achtergrondagent te laten uitvoeren kan het team zich richten op complex werk aan functies.
2. Stel de trigger in
Maak een automatiseringsregel aan die dat werk vindt op basis van een planning of een gebeurtenis. De regel start elke uitvoering, zodat de lus begint zonder dat je die hoeft te volgen.
3. Wijs het werk toe aan een codeeragent
Wijs het werkitem toe aan een codeeragent, zoals de Jira-codeeragent. De agent fungeert als een bekende identiteit en heeft daardoor alleen toegang tot wat voor die identiteit is toegestaan.
4. Voeg de controle toe
Geef de agent een objectieve test, zoals een testsuite, linter of build-opdracht om uit te voeren en zichzelf te corrigeren in zijn eigen omgeving. Wanneer de agent een pull request opent, verifieert CI de code en leidt Jira-automatisering de uitkomst door of escaleert mislukkingen.
5. Bevestig de registratie en verbreed deze daarna
Controleer het werkitem en de weergave van agentsessies om te bevestigen dat de uitvoering is vastgelegd. Zodra dat stabiel blijft, voeg je het volgende taaktype toe, nog steeds voor omkeerbaar werk. Het resultaat is een lus die zelfstandig routinematig werk vindt en afrondt, terwijl riskante beslissingen naar jou worden doorgestuurd.
Veelgestelde vragen over loop engineering
Wat is loop engineering voor AI-agents?
Het is de methode om de geautomatiseerde cyclus te ontwerpen die een agent zelfstandig uitvoert, zodat die naar een doel toewerkt zonder dat een persoon elke keer een prompt hoeft te geven.
Waarin verschilt loop engineering van human-in-the-loop?
Loop engineering ontwerpt de cyclus die de agent zelfstandig uitvoert. Human-in-the-loop ontwerpt de cyclus waarbij een persoon goedkeurt, beoordeelt of overneemt.
Wat zijn de onderdelen van een agentlus?
Ontdekking, actie, een controle, een registratie en een stap om te bepalen wat de volgende stap is, plus een duurzame registratie die de status van de ene uitvoering naar de volgende overdraagt.
Hoe voorkom je dat een agentlus voor altijd blijft draaien?
Stel vooraf een doelstatus en een budget in en geef de lus een stopvoorwaarde, zodat hij wordt afgesloten bij succes of bij het bereiken van de limiet.
Kun je AI-agentlussen uitvoeren in Jira?
Ja. automatiseringsregels triggeren de lus, een codeeragent doet het afgebakende werk en het werkitem bevat de status die de volgende uitvoering als context leest.