Betere AI-codeeragents bouwen: hoe real-time contextfeedback het verschil maakt

AI-codeerassistenten zijn krachtig, maar ze hebben nog steeds veel begeleiding nodig. Ze schrijven code, krijgen een foutmelding, en dan... stopt het proces. Ze vergeten wat er misging. Ze zien niet welke bestanden zijn gewijzigd. Zonder jouw input blijven ze blind voor wat er net is gebeurd.

Dat komt niet door de AI zelf. Het ligt aan hoe we informatie terugvoeren naar het systeem.

Observability die écht terugkoppelt

Bij de meeste agent-frameworks is observability eenrichtingsverkeer. Je logt wat er gebeurt voor later onderzoek. Maar stel dat diezelfde data direct invloed heeft op de volgende beslissing van de agent?

Dat idee staat centraal in tools zoals TMA1 v2. Het verandert hoe we agent-gestuurde ontwikkeling aanpakken.

De klassieke agent-loop ziet er zo uit:

• Agent kiest een actie
• Agent voert tools uit (bestanden lezen, commando’s draaien, code aanpassen)
• Agent krijgt het resultaat terug
• Herhaal

Maar er ontbreekt iets cruciaals: de agent krijgt geen context bij dat resultaat. Hij weet niet automatisch:

• Is de build geslaagd of mislukt?
• Welke bestanden zijn veranderd sinds het begin?
• Heeft een mens of een andere agent iets aangepast?
• Hoeveel tokens zijn er al verbruikt, en is het tijd om samen te vatten?
• Herhaalt hij dezelfde mislukte aanpak?

Van meten naar handelen

De volgende generatie tooling lost dit op door automatisch rijke context terug te geven. In plaats van te wachten tot de agent iets vraagt, krijgt hij proactief:

Build-status: Of de laatste run is geslaagd of mislukt, met recente foutmeldingen en omgevingswijzigingen. Een mislukte opdracht moet direct zichtbaar zijn, niet pas in de volgende cyclus.

Sessie-overzicht: Hoe lang loopt de sessie al? Hoeveel tool-calls en tokens zijn er verbruikt? Als de context te groot wordt, moet de agent dat zelf kunnen signaleren.

Bestandswijzigingen detecteren: Het systeem kan onderscheid maken tussen aanpassingen van de agent zelf en die van jou of een andere AI. Zo voorkom je dat de agent zegt “ik wist niet dat dat bestand al was aangepast”.

Afwijkingen herkennen: Patronen die aangeven dat de agent vastloopt. Bijvoorbeeld:

• Herhaaldelijk dezelfde file bewerken zonder dat de fout verandert
• Context die boven de 100k tokens uitkomt
• Externe bestanden die tijdens de sessie worden aangepast

Als het systeem dit detecteert, kan het de agent subtiel bijsturen.

Meerdere agents samenwerken zonder ruis

Bij grotere projecten wil je soms meerdere agents tegelijk laten werken. Groepschat-achtige samenwerking klinkt aantrekkelijk, maar het werkt slecht voor code. Te veel ruis, te hoge kosten, te veel API-verkeer. Code volgt een strak ritme:

Plan → Code → Verifiëren/Testen → Review → Itereren

De review-fase moet direct terugkoppelen. Agent A bouwt en test, Agent B reviewt en signaleert problemen. Agent A ziet precies wat Agent B heeft gevonden, in een gestructureerde context, zonder dat iedereen in een chat hoeft te zitten.

Dit vraagt om een gedeelde observability-laag. Via API’s of protocollen zoals het Model Context Protocol kan elke agent precies de informatie ophalen die hij nodig heeft uit de sessiegeschiedenis van de ander.

De feedbackloop in de praktijk

Om dit goed te implementeren heb je nodig:

1. Diepe integratiepunten: Observability-hooks op elk belangrijk moment — bij het starten van een sessie, voor elke prompt, na elke tool-uitvoering, en vóór context-compaction.

2. Slimme toewijzing: Bij een bestandswijziging moet je snel kunnen bepalen wie dat deed. Een venster van ±5 seconden rond een fsnotify-event, gekoppeld aan tool-calls of bash-commando’s, werkt meestal goed.

3. Gestructureerde contextblokken: Niet zomaar logs, maar duidelijke, machine-leesbare blokken met sessie-metadata, tool-statistieken, recente bestanden, build-status en gedetecteerde afwijkingen.

4. MCP-serverintegratie: Een Model Context Protocol-server laat agents projectstatus, build-status en sessies van andere agents opvragen via een gestandaardiseerde interface.

Wat dit oplevert

Als agents kunnen zien wat er net is gebeurd, werken ze anders. Ze:

• Herstellen sneller van fouten
• Vermijden herhaalde, mislukte strategieën
• Coördineren beter met mensen en andere agents
• Gebruiken hun token-budget efficiënter

Dit is nog een jong vakgebied, maar het patroon is duidelijk: observability die terugvoedt in de besluitvorming is de ontbrekende schakel. Daarmee veranderen agents van hulpmiddelen die constant aandacht nodig hebben in echte, zelfstandige samenwerkingspartners.

Wat komt eraan?

Naarmate AI-ondersteunde ontwikkeling verder rijpt, verwachten we:

• Betere standaarden voor context-injectie
• Geavanceerdere detectie van vastlopende agents
• Rijkere protocollen voor samenwerking tussen agents
• Integratie met bestaande workflows zoals CI/CD, versiebeheer en deployment

De agents zelf hoeven niet per se slimmer te worden. Het is de infrastructuur eromheen — de observability, de feedbackloops, de coördinatielaag — die het verschil gaat maken.

Bouw je vandaag met AI-agents? Kijk dan eens naar wat ze nu niet zien. Welke context zou hun volgende beslissing écht veranderen? Daar zitten waarschijnlijk je grootste winstpunten.