💬 NLP

Dialogue SWE-Bench: A Benchmark for Dialogue-Driven Coding Agents

Dit artikel introduceert Dialogue SWE-Bench, een nieuwe benchmark en een op persona gebaseerde gebruikerssimulator voor het evalueren van het vermogen van coding agents om software engineering-problemen via dialoog op te lossen, wat onthult dat dialoogvaardigheid een afzonderlijke dimensie van prestaties is die niet noodzakelijkerwijs correleert met de kracht van het coding model.

Oorspronkelijke auteurs: Brendan King, Jeffrey Flanigan

Gepubliceerd 2026-06-15

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Brendan King, Jeffrey Flanigan

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je probeert een kapotte broodrooster te repareren.

De Oude Manier (Huidige Benchmarks):
Op dit moment, wanneer we AI-codeerassistenten testen, gedragen we ons als een robot die een robot een perfecte, 10 pagina's tellende handleiding geeft. De handleiding zegt: "De broodrooster is kapot omdat het verwarmingselement loszit. Draai het even vast." De AI leest de handleiding, repareert de broodrooster en wij geven het een gouden ster.

Het probleem? Echte mensen praten niet zo. Wij hebben geen perfecte handleidingen. Wij zeggen: "Hé, mijn broodrooster doet raar," en de AI moet vragen: "Maakt hij een geluid? Komt er rook uit? Wat gebeurt er als je de hendel indrukt?"

De Nieuwe Manier (Dialogue-SWEBench):
Dit paper introduceert een nieuwe testomgeving genaamd Dialogue-SWEBench. In plaats van de AI een perfecte handleiding te geven, hebben ze een simulatie opgezet waarbij de AI met een "geest-gebruiker" (ghost user) moet praten om een echt softwareprobleem op te lossen.

Zo hebben ze het gebouwd:

1. De "Geest-Gebruiker" Simulator

De onderzoekers hebben een speciaal AI-programma gemaakt om de rol van de menselijke gebruiker te spelen.

De Persona: Deze geest-gebruiker heeft een persoonlijkheid (zoals "angstig en voorzichtig" of "lui en ongeduldig").
De Kennis: De geest-gebruiker kent het volledige verhaal van de bug (zoals een geheim script), maar het is strikt verboden om alles in één keer aan de AI te vertellen. De gebruiker moet details pas onthullen als erom gevraagd wordt.
De Zelfcorrectie: Als de geest-gebruiker per ongeluk iets onmogelijks zegt (zoals "Ik heb de code net op mijn telefoon gedraaid"), vangt de simulator zichzelf op, zegt "Oeps, dat kan ik niet," en herschrijft het bericht om het realistisch te maken. Dit zorgt ervoor dat de test eerlijk verloopt.

2. De Testronde

In deze nieuwe test kan de AI-codeeragent niet simpelweg een bestand bekijken en het repareren. De agent moet:

Luisteren naar de vage klacht van de gebruiker ("Mijn code crasht!").
Verhelderende vragen stellen ("Welke foutmelding krijg je te zien?").
Het antwoord krijgen.
De code repareren.
De reparatie verifiëren met de gebruker.

Als de AI probeert het antwoord te raden zonder te vragen, of als de AI te veel onzinnige vragen stelt, faalt het.

3. De Grote Verrassing

De onderzoekers hebben de slimste coderende AI's die beschikbaar zijn (zoals GPT-5 en anderen) getest in deze nieuwe "chat"-omgeving. Ze kwamen tot een verrassende ontdekking:

Een geweldige programmeur zijn maakt je niet automatisch een geweldige gesprekspartner.

De "Groot Brein" Valstrik: De grootste, krachtigste modellen (de "Grote Breinen") waren in deze nieuwe "chat"-omgeving juist slechter in het gesprek deel. Ze hadden de neiging om te veel onnodige vragen te stellen of raakten in de war van de chatflow.
De "Klein maar Slim" Winnaar: Een iets kleiner model (GPT-5-mini) deed het beter in het gesprek en loste meer problemen op voor minder geld.
Het Geheime Ingrediënt: De onderzoekers bouwden een nieuw type agent dat een "Schema" gebruikt (denk aan een checklist of een mentaal whiteboard). Terwijl de AI chat, vult het vakjes op zijn checklist in: Wat is de bug? Wat is het verwachte resultaat? Wat ontbreekt er?
- Deze "Schema-gestuurde" agent was het beste in het oplossen van problemen omdat de agent georganiseerd bleef tijdens het gesprek, in plaats van gewoon te gokken.

4. Het Eindoordeel

Het paper concludeert dat we coderende agents tot nu toe hebben getest alsoals robots die alleen in een lab werken. Maar in de echte wereld zijn ze teamgenoten die met mensen samenwerken.

Codeervaardigheid ≠ Chatvaardigheid: Een model kan briljant zijn in het schrijven van code, maar verschrikkelijk in het achterhalen van wat de mens echt nodig heeft.
De Oplossing: Om betere coderende assistenten te maken, moeten we ze trainen om betere luisteraars en vraagstellers te worden, niet alleen betere programmeurs.

Kortom: Het paper heeft een "chat-simulator" gebouwd om te testen of coderende AI's daadwerkelijk met mensen kunnen praten om bugs op te lossen. Ze ontdekten dat de grootste, duurste modellen niet altijd de beste gesprekspartners zijn, en dat het geven van een mentale checklist de AI helpt om problemen veel beter op te lossen.

Technische Samenvatting: Dialogue-SWEBench

Probleemstelling

Huidige benchmarks voor programmeeragenten, zoals SWE-Bench, evalueren systemen in een volledig autonome setting waarbij agenten aan het begin een volledige en correcte probleemspecificatie ontvangen. Deze aanpak slaat de interactieve aard van echt software engineering over, waarbij gebruikers regelmatig in dialoog gaan om de output van de agent te corrigeren, af te wijzen of te verduidelijken. Studies wijzen uit dat gebruikers de output van agenten in 44% van de gevallen corrigeren, terwijl agenten zelden om verduidelijking vragen (1-2%). Bovendien gaan bestaande benchmarks er vaak van uit dat een perfecte specificatie beschikbaar is, terwijl problemen in de echte wereld vaak ondergespecificeerd of vaag zijn. Bijgevolg is er een aanzienlijke kloof tussen huidige evaluatiemetrieken en de werkelijke capaciteiten die vereist zijn voor interactieve, door dialoog gestuurde programmeeragenten.

Methodologie

Dialogue-SWEBench Benchmark

De auteurs introduceren Dialogue-SWEBench, een benchmark die ontworpen is om het vermogen van programmeeragenten te evalueren om echte software engineering (SWE) problemen uitsluitend via dialoog met een gebruiker op te lossen. De benchmark wordt geconstrueerd door taken uit SWE-Bench Verified te herformuleren:

Input Transformatie: In plaats van de volledige issue-tekst als een statische specificatie te verstrekken, begint de taak met een vaste, initiële gebruikersquery ( $u_1$ ) die de intentie van de gebruiker weerspiegelt, maar cruciale details weglaat die nodig zijn voor de oplossing.
Interactieve Loop: Agenten opereren in een omgeving waarin ze standaard programmeeracties kunnen uitvoeren (bestanden bewerken, tests draaien) en een nieuwe message_user actie hebben. Deze actie stelt de agent in staat om de gebruiker te bevragen, waarbij een gesimuleerd antwoord als observatie wordt ontvangen.
Terminatie: De loop eindigt wanneer de agent een finish actie uitvoert en een git-patch indient. Succes wordt bepaald door of de patch alle bijbehorende executietests doorstaat.

Gebruikerssimulator

Om een getrouwe en reproduceerbare evaluatie te garanderen, hebben de auteurs een persona-gegronde gebruikerssimulator ontworpen met behulp van een gekwantiseerde LLaMa 3.3 70B model.

Kennisgronding: De simulator is geconditioneerd op de volledige originele GitHub issue-tekst ( $I_{text}$ ), maar is beperkt in het toegang krijgen tot de code-repository of het zelf draaien van code. Het moet optreden als een gebruiker die het probleem kent, maar de oplossing niet kan implementeren.
Zelf-revisie Mechanisme: Om hallucinaties te voorkomen en aan de omgevingsrestricties te voldoen (bijv. de gebruiker kan geen code draaien), gebruikt de simulator een zelf-revisiestap. Een kandidaat-gebruikersantwoord wordt gegenereerd, gevalideerd door hetzelfde LLM op schendingen (zoals het beweren code te draaien of het breken van het karakter), en indien nodig aangepast voordat het naar de agent wordt geretourneerd.
Persona's: Om de dialoogdiversiteit te vergroten, krijgt elk probleem een specifieke gebruikerspersona toegewezen (bijv. "voorzichtig", "perfectionist", "pragmatisch"), die de toon en het gedrag van de gesimuleerde reacties beïnvloedt.

Schema-gestuurde Agent

De auteurs stellen een nieuwe schema-gestuurde programmeeragent voor om de dialoogprestaties te verbeteren. Deze agent gebruikt prompts om een gestructureerde interne representatie (een "schema") van de dialoogstatus bij te houden.

Workflow: De agent bepaalt eerst het type issue (bijv. bug, feature) en stelt een schema op met sleutels voor cruciale details (bijv. "verwacht gedrag", "reproductiestappen").
Statusbeheer: Waarden worden gemarkeerd als UNKNOWN totdat ze besproken zijn. De agent krijgt de instructie om deze hiaten aan te vullen via dialoog voordat er wordt overgegaan tot code-exploratie en patchgeneratie. Deze structuur is ontworpen om de agent te begeleiden bij het stellen van gerichte, informatiezoekende vragen in plaats van aannames te doen.

Evaluatiemetrieken

Resolutiepercentage: De primaire metriek is het percentage dialogen dat resulteert in een patch die alle executietests doorstaat.
Dialoogkwaliteit: De auteurs introduceren automatische evaluaties voor Naturalness (gemak van begrip) en Coherence (logische progressie naar de oplossing) met behulp van een LLM-as-a-Judge (Gemma 4 31B-IT), gevalideerd tegen menselijke annotaties.

Belangrijkste Bijdragen

Dialogue-SWEBench: Een benchmark-dataset die 500 real-world SWE-problemen transformeert naar interactieve, door dialoog gestuurde taken waarbij agenten issues moeten oplossen zonder een volledige initiële specificatie.
Gebruikerssimulator: Een nieuwe, open-source, persona-gegronde simulator met een zelf-revisiemechanisme om realistische, aan de restricties voldoende gebruikersreacties te produceren voor online evaluatie.
Schema-gestuurde Agent: Een nieuwe agent-architectuur die dialoog-schema's gebruikt om expliciet ontbrekende informatie bij te houden, wat resulteert in verbeterde prestaties ten opzien van sterke baselines.
Automatische Dialoogevaluatie: Een LLM-as-a-Judge framework voor het beoordelen van de natuurlijkheid en coherentie van programmeeragent-dialogen.

Resultaten

De auteurs evalueerden state-of-the-art closed (GPT-5, GPT-5-mini) en open-weight (Qwen 3 Coder, Devstral 2 Small) modellen met drie agent-configuraties: OpenHands (off-the-shelf), OH Interactive (baseline voor ambiguïteitsresolutie), en hun voorgestelde Schema-Guided agent.

Prestaties: De schema-gestuurde agent behaalde het hoogste gemiddelde resolutiepercentage (46,9%) over alle modellen, waarmee het OpenHands (32,9%) en OH Interactive (44,1%) overtrof. Dit bereikte het tegen de laagste gemiddelde kosten.
Dialoog vs. Programmeervaardigheid: De resultaten geven aan dat sterkere programmeermodellen niet noodzakelijkerwijs vertalen naar betere dialoogagenten. Zo presteerde GPT-5-mini vaak gelijk aan of zelfs beter dan de grotere GPT-5 wat betreft resolutiepercentages, terwijl het een fractie van de kosten bedroeg en natuurlijkere dialogen produceerde.
Informatiezoekend vermogen: Er is een sterke correlatie tussen het aantal informatiezoekende dialoogstappen en de resolutiepercentages. De schema-gestuurde agent maakte consequent meer informatiezoekende stappen dan de baselines, wat cruciaal was voor succes.
Ablatie-studies: Het verwijderen van de gebruikerssimulator (waardoor single-turn resolutie werd afgedwongen) verminderde de prestaties drastisch (bijv. GPT-5-mini daalde van 68,0% naar 40,0%), wat bevestigt dat multi-turn dialoog essentieel is voor het oplossen van deze taken.
Kwaliteitsanalyse: Hoewel GPT-5 een hoge resolutie behaalde op moeilijke taken, leed het aan lagere naturalness-scores door verbositeit en herhaling. De schema-gestuurde aanpak verbeterde over het algemeen de coherentie.

Betekenis

Het artikel betoogt dat dialoogvaardigheid een onderscheidende en momenteel onderbelichte dimensie is van de prestaties van programmeeragenten. De bevindingen suggereren dat het simpelweg opschalen van programmeermodellen of het bieden van betere specificaties onvoldoende is voor inzet in de echte wereld. In plaats daarvan is het vermogen om deel te nemen aan multi-turn, informatiezoekende dialoog een kritieke factor voor het oplossen van echte software engineering-problemen. De auteurs stellen dat toekomstig onderzoek de intersectie van programmeer- en dialoogcapaciteiten moet adresseren om agenten te bouwen die effectief kunnen samenwerken met menselijke gebruikers, in plaats van te opereren als volledig autonome, specificatie-afhankelijke systemen.