Ga naar de hoofdinhoud

Agentic Board

Een MCP-gestuurd ticketplatform waarop coding agents werk opnemen, analyseren, implementeren en testen, met gekoppeld bewijs en een menselijke quality gate.

In één oogopslag

Projecttype
Prototype
Jaar
2026
Projectfase
Actief
Rol van 5A Technologies
Co-development met Infium, agentic architectuur, MCP-workflowontwerp, quality gates en productimplementatie.
Technologieën
  • TypeScript
  • Next.js
  • React
  • Node.js
  • PostgreSQL
  • Redis
Agentic Board — gecontroleerde agentic deliveryflowHover of focus voor uitleg. Op mobiel tikt u een fase open.

Tienfasenworkflow van Agentic Board: planvorming wordt via MCP-tickets, boardcontext en prioritering omgezet in agentanalyse, implementatie, QA, pull-requestsync en menselijke review. 1. Plan structureren: Functioneel, technisch, security en QA 2. Tickets via MCP bouwen: Fases krijgen scope, criteria en afhankelijkheden 3. Boardcontext koppelen: Sprint, team, repository en agentpool 4. Wegen en prioriteren: Waarde, risico, rechten en afhankelijkheden 5. Ticket uitvoerbaar maken: Scope en criteria zijn klaar voor claim 6. Agent claimt ticket: Een passende toegestane taak wordt vergrendeld 7. Context en code analyseren: Aanpak, risico's en blokkades worden bepaald 8. Implementeren en valideren: Code, tests en verplichte checks 9. PR en board synchroniseren: Bewijs, status en PR blijven gekoppeld 10. Menselijke quality gate: Approven, herwerken, weigeren of blokkeren Verbindingen: Plan structureren naar Tickets via MCP bouwen (gestructureerd plan). Tickets via MCP bouwen naar Boardcontext koppelen (tickets met criteria). Boardcontext koppelen naar Wegen en prioriteren (board- en projectcontext). Wegen en prioriteren naar Ticket uitvoerbaar maken (gewogen uitvoerbaarheid). Ticket uitvoerbaar maken naar Agent claimt ticket (toegelaten ticket). Agent claimt ticket naar Context en code analyseren (vergrendelde opdracht). Context en code analyseren naar Implementeren en valideren (afgebakende aanpak). Implementeren en valideren naar PR en board synchroniseren (code, tests en bewijs). PR en board synchroniseren naar Menselijke quality gate (reviewklare pull request). Menselijke quality gate naar Context en code analyseren (changes requested). PR en board synchroniseren naar Ticket uitvoerbaar maken (volgend toegestaan ticket).

Agentic Board · systeemflow10 fasen · menselijke quality gate en herwerking
  1. Plan structurerenFunctioneel, technisch, security en QA
    Plan, uitvoerbaar ticket en claimEen plan wordt opgesplitst in uitvoerbare onderdelen

    Functionele, technische, security- en QA-input blijft de bron voor scope, acceptatiecriteria en kwaliteitsvereisten van iedere fase en subfase.

  2. Tickets via MCP bouwenFases krijgen scope, criteria en afhankelijkheden
    MCP, boardcontext, prioritering en boardsyncDe ticketfactory maakt een controleerbaar uitvoeringscontract

    Ieder uitvoerbaar onderdeel krijgt scope, acceptatiecriteria, afhankelijkheden, sprint, repository, risico, bewijsvereisten, toegestane acties en reviewbeleid.

  3. Boardcontext koppelenSprint, team, repository en agentpool
    MCP, boardcontext, prioritering en boardsyncProjectcontext en toegang worden aan het ticket gekoppeld

    Board, Wiki en Testplan leveren de relevante projectafspraken, repositorycontext, testvereisten, rechten en beschikbare runnercapaciteiten.

  4. Wegen en prioriterenWaarde, risico, rechten en afhankelijkheden
    MCP, boardcontext, prioritering en boardsyncNiet ieder ticket is op ieder moment uitvoerbaar

    Prioriteit, gewicht, afhankelijkheden, repository, risico, rechten en runnercapaciteiten bepalen welk werk verantwoord kan worden opgenomen.

  5. Ticket uitvoerbaar makenScope en criteria zijn klaar voor claim
    Plan, uitvoerbaar ticket en claimHet ticket verbindt planning, uitvoering en review

    Een uitvoerbaar ticket vormt de vaste overeenkomst tussen de oorspronkelijke vraag, agentacties, vereist kwaliteitsbewijs en menselijke beoordeling.

  6. Agent claimt ticketEen passende toegestane taak wordt vergrendeld
    Agentanalyse, implementatie en QAClaiming voorkomt gelijktijdige uitvoering van hetzelfde werk

    Een geschikte runner claimt één toegestaan ticket. Locking en idempotency begrenzen dubbele uitvoering en houden eigenaarschap en status zichtbaar op het board.

  7. Context en code analyserenAanpak, risico's en blokkades worden bepaald
    Agentanalyse, implementatie en QADe agent onderzoekt de opdracht vóór implementatie

    De runner analyseert toegestane repositorycontext, afhankelijkheden, acceptatiecriteria, risico's en ontbrekende informatie en legt een afgebakende aanpak vast.

  8. Implementeren en validerenCode, tests en verplichte checks
    Agentanalyse, implementatie en QAWijzigingen en kwaliteitsbewijs ontstaan in een begrensde workspace

    De agent voert de wijziging uit en draait de vereiste build-, test-, security- en accessibilitychecks. Een onoplosbare blokkade blijft expliciet zichtbaar voor menselijke input.

  9. PR en board synchroniserenBewijs, status en PR blijven gekoppeld
    MCP, boardcontext, prioritering en boardsyncHet ticket ontvangt het controleerbare uitvoeringsresultaat

    Commits, checks, bewijs, resterende risico's en de pull-requestreferentie worden aan hetzelfde ticket en de oorspronkelijke acceptatiecriteria gekoppeld.

  10. Menselijke quality gateApproven, herwerken, weigeren of blokkeren
    Menselijke quality gate en herwerkingEen reviewer beslist wat met de wijziging gebeurt

    Een mens kan goedkeuren, gerichte wijzigingen vragen, weigeren of blokkeren. Mergen, deployen, releasen en sluiten gebeuren alleen wanneer het ingestelde beleid iedere actie expliciet toestaat.

Plan, uitvoerbaar ticket en claimMCP, boardcontext, prioritering en boardsyncAgentanalyse, implementatie en QAMenselijke quality gate en herwerkingAgentic Board koppelt planning, ticketcontext, agentuitvoering, bewijs en review; herwerking en ticketselectie volgen aparte feedbacklussen.

Na boardsync kan een runner een volgend toegestaan ticket opnemen; review blijft afzonderlijk actief.

Mergen, deployen, releasen en sluiten blijven afhankelijk van expliciet ingesteld beleid.

Claiming, idempotency en locking verhinderen dat runners hetzelfde ticket tegelijk uitvoeren.

Een blokkade vraagt menselijke context, toegang of een externe beslissing.

In het kort

Agentic Board is een gedeeld ticketplatform voor menselijke teams en geautoriseerde coding agents. Functionele en technische plannen worden via Model Context Protocol omgezet naar gestructureerde tickets met scope, acceptatiecriteria, afhankelijkheden, risico, rechten en reviewbeleid.

Een passende runner kan een toegestaan ticket claimen, de repository analyseren, een wijziging implementeren, kwaliteitscontroles uitvoeren en een pull request koppelen. Ticketstatus, bewijs en reviewbeslissingen blijven bij dezelfde opdracht. Een menselijke quality gate bepaalt wat wordt goedgekeurd, herwerkt, geweigerd of geblokkeerd.

Agentic Board is een gezamenlijk initiatief van 5A Technologies en Infium. Een proof of concept wordt gebruikt in een beperkte private pilot. De bredere publieke productrelease is nog in ontwikkeling.

  • Context: gedeelde softwaredelivery voor menselijke teams en geautoriseerde coding agents
  • Project: gezamenlijk initiatief van 5A Technologies en Infium
  • Status: proof of concept in een beperkte private pilot; bredere publieke productrelease in ontwikkeling
  • Rol van 5A Technologies: agentic product- en workflowarchitectuur, ticketmodel, lifecycle, synchronisatie en menselijke quality gates
  • Kernprincipes: afgebakende tickets, gecontroleerde agentuitvoering, kwaliteitsbewijs en menselijke besluitvorming

Belangrijk ontwerpprincipe

Een agent ontvangt een begrensde opdracht en toegestane acties. Mergen, deployen, releasen en sluiten blijven afzonderlijk onder het ingestelde beleid en de menselijke quality gate vallen.

Het probleem

Zonder gedeelde structuur raakt agentisch softwarewerk versnipperd:

  • opdrachten blijven verspreid over chats, issues en losse prompts;
  • agents kunnen projectcontext of afhankelijkheden missen;
  • meerdere runners kunnen hetzelfde werk opnemen;
  • code, tests, bewijs en reviewbeslissingen raken van elkaar los.

Agentic Board maakt van die losse interacties één navolgbare deliveryflow. Het board blijft de centrale werkvoorraad en het ticket vormt de overeenkomst tussen planning, uitvoering, validatie en menselijke beslissing.

De oplossing in vier fasen

Het board en het ticket verbinden planning, uitvoering, validatie en menselijke besluitvorming in één navolgbare lifecycle.

Van plan naar uitvoerbaar ticket

Een plan wordt opgesplitst in uitvoerbare fases en subfases. De MCP-ticketflow koppelt ieder onderdeel aan onder meer:

  • duidelijke scope en acceptatiecriteria;
  • sprint, team en repository;
  • prioriteit, gewicht en afhankelijkheden;
  • risico en vereiste kwaliteitschecks;
  • bewijsvereisten en toegestane agentacties;
  • het review- en afsluitbeleid.

Boardcontext, beschikbare runners en rechten bepalen vervolgens welk ticket werkelijk uitvoerbaar is. Een agent krijgt dus geen onbeperkte werkvoorraad of toegang.

Claimen, analyseren en uitvoeren

Een runner mag alleen verder wanneer ticket, projectcontext, rechten en configuratie dat toelaten. De uitvoering omvat:

  • het selecteren van een passende runner voor een toegestaan ticket;
  • claiming, idempotency en locking om gelijktijdige uitvoering te begrenzen;
  • analyse van relevante code, context, risico's en afhankelijkheden vóór implementatie;
  • wijzigingen in een begrensde workspace met verplichte build-, test- en andere checks.

De resultaten van die checks leveren bewijs voor het ticket en de gekoppelde pull request.

Kwaliteitsbewijs en boardsynchronisatie

De pull request bundelt:

  • de wijziging en relevante commits;
  • testresultaten;
  • functionele controles;
  • resterende risico's;
  • een verwijzing naar de oorspronkelijke acceptatiecriteria.

Na boardsynchronisatie kan een runner een volgend toegestaan ticket opnemen terwijl de review van eerder werk afzonderlijk actief blijft. Uitvoeringsstroom en reviewstroom blijven gekoppeld, maar behouden elk hun eigen status.

Menselijke review en gerichte herwerking

Een reviewer kan:

  • goedkeuren;
  • gerichte wijzigingen vragen;
  • weigeren;
  • blokkeren.

Feedback keert naar hetzelfde ticket en activeert een begrensde herwerking. Mergen, deployen, releasen en sluiten gebeuren alleen wanneer het ingestelde beleid dat afzonderlijk en expliciet toestaat.

Platformarchitectuur

Het platform brengt werkvoorraad, projectcontext, kwaliteitsbewijs en uitvoering samen zonder die verantwoordelijkheden tot één onbeperkte agent te herleiden.

Board

Het Board bewaart tickets, prioriteiten, afhankelijkheden, runs, bewijs, pull requests en reviewbeslissingen. Ticket- en policylogica, PostgreSQL, scheduling en locking ondersteunen de gecontroleerde lifecycle.

Wiki

Een gekoppelde Wiki levert afgebakende architectuur-, domein- en projectcontext. Een agent kan daardoor relevante informatie ophalen zonder alle documentatie ongericht in één prompt te laden.

Testplan

Het Testplan verbindt acceptatiecriteria, scenario's, quality gates en resultaten. Board, Wiki en Testplan delen dezelfde project- en toegangscontext.

Runners, MCP en observability

Een MCP-laag en Git-integratie verbinden het platform met lokale of gehoste runners die dicht bij een toegestane repository in een geïsoleerde workspace werken. Observability houdt runs, fouten en beslissingen navolgbaar.

De MCP-laag maakt de workflow niet afhankelijk van één specifieke coding agent. Welke runners werkelijk worden ondersteund, blijft afhankelijk van de geverifieerde implementatie en projectconfiguratie.

Hosted en dedicated model

De productvisie ondersteunt een beheerde variant voor kleinere organisaties en een afgescheiden dedicated of self-hosted variant voor omgevingen met eigen identity-, Git-, CI/CD-, data- en infrastructuurgrenzen.

Dit zijn deliverymodellen in ontwikkeling, geen claim van algemene beschikbaarheid. De openbare productwebsite kondigt nog geen algemene lanceringsdatum aan.

Onze bijdrage en kwalitatief resultaat

Binnen de samenwerking met Infium gaven we vanuit 5A Technologies vorm aan de agentic product- en workflowarchitectuur, het MCP-gedreven ticketmodel, lifecyclebeheer, prioritering en agentselectie, de flow van analyse naar implementatie en QA, pull-request- en boardsynchronisatie, menselijke review- en herwerkgates en de verdere visie voor Board, Wiki en Testplan.

Agentic Board brengt planning, begrensde agentuitvoering, kwaliteitsbewijs en menselijke besluitvorming samen in één controleerbare flow. Agents ontvangen een afgebakende opdracht in plaats van alleen een prompt, terwijl teams controle behouden over wijzigingen die in hun software terechtkomen.

Bewuste grenzen

  • Agentic Board wordt niet als algemeen beschikbaar product voorgesteld.
  • Er worden geen besparingen, volumes, slaagpercentages of autonome succesclaims gepubliceerd.
  • Coding agents krijgen geen onbeperkte repository- of infrastructuurtoegang.
  • Automatisch mergen, deployen, releasen of sluiten is altijd beleidsafhankelijk.
  • Interne tools, prompts, tokens, repositories, klantdata en securityconfiguratie blijven buiten de publieke inhoud.

Wat dit project demonstreert

Dit project toont hoe 5A Technologies:

  • functionele en technische plannen naar afgebakende, uitvoerbare tickets vertaalt;
  • rechten, claiming, idempotency en locking in agentuitvoering verankert;
  • implementatie, kwaliteitschecks, bewijs, pull requests en boardstatus traceerbaar verbindt;
  • agentuitvoering en menselijke review gekoppeld maar afzonderlijk bestuurbaar houdt;
  • via MCP meerdere geschikte runners kan ondersteunen zonder één agenttype als vast uitgangspunt te nemen;
  • Board, Wiki en Testplan binnen dezelfde project- en toegangscontext samenbrengt.

Wilt u een gelijkaardige oplossing bespreken?

Vertel ons waar uw proces vandaag vertraagt of waar AI en automatisering beter moeten samenwerken. We bekijken samen welke controleerbare aanpak past.

Bespreek uw proces