Van AI-coding-agents tot Agentforce

Agentic Engineering is het toepassen van software-engineeringdiscipline op AI-gedreven werk op Salesforce. Waar een proof-of-concept-agent in een paar klikken in elkaar wordt gezet, behandelt Agentic Engineering elk resultaat (een Agentforce-agent, maar net zo goed een Apex-class, een Flow of een headless component) als iets dat ontworpen, versiebeheerd, getest, uitgerold en gemonitord moet worden, net als elke andere bedrijfskritische applicatie.

De term wordt in het Engels sterk geclaimd door Salesforce en grote internationale system integrators, maar is in het Nederlands nagenoeg onbezet. Outbirds gebruikt Agentic Engineering bewust als naam voor een concrete werkwijze, geen modewoord. Het verschil met een buzzword zit in de lifecycle: een agent of component is pas engineered als hij voorspelbaar handelt binnen vastgestelde grenzen, zijn gedrag herleidbaar is, en je hem veilig kunt aanpassen zonder regressie.

Voor Outbirds is dit geen losstaand product, maar een van de drie facetten van een partnerschap rond Salesforce. Implementatie (Field Service, Service Cloud, Revenue Cloud), headless (Salesforce als API-first backend) en agentic (AI-coding-agents en runtime-agents) horen bij elkaar. Headless is daarbij de onderscheidende hoek, en agentic is het bewijs dat we dit nu al doen.

Voor service-intensieve en asset-intensieve organisaties is dat onderscheid essentieel. Een agent die orders aanmaakt, serviceafspraken plant of klantvragen afhandelt op de geinstalleerde basis, raakt direct aan processen, data en compliance. Daar past geen experiment, daar past engineering.

Een groot deel van het werk speelt zich af in de IDE en de CLI, niet in een agentgesprek. Outbirds zet AI-coding-agents in (Claude Code en OpenAI Codex, en breder MCP-compatibele agents zoals Cursor en Windsurf) om Agentforce-agents, Apex, Flows, Lightning-componenten en headless-koppelingen sneller en betrouwbaarder te bouwen. We noemen dit toegepaste agentic engineering op Salesforce: de agent draait in de tooling die de developer al gebruikt en spreekt de org aan via het Model Context Protocol (MCP), een open standaard van Anthropic.

De technische basis hiervoor kwam op TrailblazerDX 2026 (15 april 2026) samen onder Salesforce Headless 360 en de Salesforce DX MCP Server. Headless 360 ontsluit het platform als API, MCP-tool en CLI-commando (ruim 4.000 bestaande API’s, meer dan 60 MCP-tools, meer dan 220 CLI-commando’s en ruim 30 voorgeconfigureerde coding skills). De DX MCP Server (Beta) geeft MCP-compatibele agents gestructureerde toegang om objectschema’s te bevragen, Apex-classes te maken, Flows en validatieregels te wijzigen, scratch orgs te maken, tests te draaien en metadata te deployen, zonder de IDE te verlaten. Tools als ApexGuru brengen kwaliteit direct in de workflow.

Daarnaast is er Agentforce Vibes, de eigen coding-agent van Salesforce met multi-model-ondersteuning (onder meer Claude Sonnet 4.5 en GPT-5), die integreert met Salesforce-tools als Code Analyzer en DevOps Center. Belangrijk om te onthouden: dit verdiept hoe je op Salesforce bouwt. De metadata en code blijven van jou en blijven in Salesforce; de agents zijn een snellere, betrouwbaardere manier om die te maken.

Agentforce is het AI-agentplatform van Salesforce, native ingebouwd in het platform. Omdat het op het platform draait, heeft een runtime-agent directe toegang tot je CRM-data, metadata, het beveiligingsmodel en de bestaande automatisering (Flows, Apex). Je bouwt agents zonder eerst een aparte integratielaag op te tuigen, en Salesforce blijft de single source of truth.

De kern van Agentforce is de Atlas Reasoning Engine. Die werkt in drie stappen: hij begrijpt de intentie en scope van een vraag, bepaalt welke data en acties nodig zijn, en voert die acties vervolgens autonoom uit om de taak af te ronden. Bij een follow-upvraag kan de agent ook zijn redenering toelichten.

Je configureert een agent in de Agent Builder, de visuele bouwomgeving binnen Salesforce. Daar definieer je de rol van de agent, koppel je Topics, Instructions en Actions en stel je grounding in via Data Cloud. Outbirds ziet Agentforce als de runtime-motor, en Agentic Engineering als de manier waarop je die motor verantwoord inbouwt in je organisatie.

Deze drie worden vaak door elkaar gehaald, maar verschillen fundamenteel in autonomie.

Een chatbot (zoals een klassieke Einstein Bot) volgt vooraf gedefinieerde dialogen, intents en flows. Hij is deterministisch en kan niet omgaan met vragen buiten het script. Een copilot is een digitale assistent: hij helpt een mens binnen zijn werk, maar wacht op instructies en handelt niet zelfstandig.

Een AI-agent gedraagt zich als een digitale medewerker. Hij plant en voert meerstapsacties uit richting een doel, neemt beslissingen op basis van context en past zich aan tijdens een gesprek of workflow. Een Agentforce-agent kan klantgericht en grotendeels autonoom werken, zonder dat een mens elke stap aanstuurt.

Dat verschil bepaalt hoe je bouwt en test. Een chatbot test je op zijn dialoogpaden. Een autonome agent moet je testen op gedrag onder variatie, op zijn grenzen en op wat hij niet mag doen. Dat is precies waarom Agentic Engineering nodig is zodra je voorbij de copilot-fase gaat.

De Atlas Reasoning Engine stuurt op drie bouwstenen die je in Agent Builder configureert.

Topics zijn de jobs-to-be-done van de agent. Elke Topic koppelt aan een herkenbare gebruikersintentie, bijvoorbeeld serviceafspraak inplannen of orderstatus opvragen. Atlas leest de input en kiest de meest relevante Topic.

Instructions horen bij een Topic en zijn in natuurlijke taal geschreven, vergelijkbaar met prompts. Samen met de scope en beschrijving van de Topic vormen ze de guardrails: ze bepalen hoe de agent een uitkomst moet leveren en wat hij wel en niet mag.

Actions zijn de concrete handelingen die de agent kan uitvoeren, gekoppeld aan een Topic. Achterliggend zijn dit Salesforce Flows, Apex-classes of integraties. Sommige acties halen vooraf data op om het antwoord te onderbouwen, andere voeren na de redeneerstap een effect uit, zoals een record aanmaken of bijwerken.

Goede Agentic Engineering begint hier: scherp afgebakende Topics, expliciete Instructions en herbruikbare, veilig ontworpen Actions. Slordige afbakening leidt tot een agent die de verkeerde Topic kiest of buiten zijn mandaat handelt. Juist deze Flows, Apex-classes en metadata bouwen we vaak samen met AI-coding-agents in een sandbox of scratch org, voordat ze gevalideerd naar productie gaan.

Data-veiligheid heeft twee kanten, en het is belangrijk die niet door elkaar te halen. De kernzin voor beide: jouw werkomgeving en data, altijd veilig en enterprise-grade.

Bij AI-ondersteunde ontwikkeling werken de AI-coding-agents primair op broncode, metadata en configuratie in jouw eigen omgeving. We werken sandbox-first of scratch-first, en een scratch org bevat per definitie geen data of metadata uit je productie-org. Daardoor blijft klantdata in de Salesforce-org en gaat die niet naar het model. Tegelijk zijn we hier niet naief: de Headless 360- en MCP-tools kunnen technisch ook SOQL, DML en data-export tegen een org uitvoeren, en kunnen tegen productie draaien. Daarom perken we dat bewust in met een least-privilege integration user, expliciete org-allowlisting (de –orgs flag) en selectieve tools (de –tools flag), zodat een agent niet meer kan zien of doen dan strikt nodig. Salesforce levert de toegangslaag, maar niet de code-governancelaag: eigen quality gates, code review, tests en deploy-gates blijven nodig en zijn onderdeel van de Outbirds-aanpak.

Bij runtime-agents (Agentforce) loopt beveiliging via de Einstein Trust Layer, een laag met guardrails tussen je data en het taalmodel. De kern: zero data retention (externe modelproviders bewaren je data niet en data wordt na het antwoord verwijderd), dynamic grounding op verifieerbare data uit Data Cloud om hallucinaties te beperken, data masking van gevoelige velden, plus toxiciteitsdetectie en audit logging. Een Agentforce-agent erft bovendien de identiteit, sharing rules, field-level security, permission sets, validatieregels en governor limits van de org. Voor AVG- en GDPR-vraagstukken is de combinatie van het Salesforce-beveiligingsmodel, grounding en de Trust Layer de technische basis, maar de verantwoorde inrichting blijft mensenwerk.

Een agent is geen eenmalige oplevering, maar software met een levenscyclus. Outbirds hanteert een herhaalbare aanpak: ontwerpen, gronden, testen, uitrollen, monitoren.

Ontwerpen: Topics, Instructions en Actions definieren op basis van echte processen en het mandaat van de agent. De achterliggende Flows en Apex bouwen we waar mogelijk met AI-coding-agents in een sandbox of scratch org.

Gronden in Data Cloud: de agent verbinden met relevante, schone databronnen zodat antwoorden feitelijk zijn. Data Cloud levert grounding, analytics en audit trails.

Testen in het Agentforce Testing Center: gedrag valideren voordat je naar productie gaat. Let op: bepaalde features, zoals Data Cloud grounding en audit logging, gedragen zich anders in sandbox dan in productie, dus testresultaten moeten in context worden gelezen.

Uitrollen via DevOps: agents, code en metadata gecontroleerd van sandbox naar productie brengen, met versiebeheer en deploy-gates in plaats van handmatig klikken. Hier komen de eigen quality gates samen die agent-output door dezelfde review als mensenwerk laten gaan.

Monitoren via de Trust Layer: interacties, audit trails en gedrag in productie volgen en bijsturen.

Deze cyclus is wat Agentic Engineering onderscheidt van een snel experiment: je kunt een agent veilig blijven verbeteren zonder regressie.

Agentforce en Microsoft Copilot Studio lossen verwante problemen op, maar vanuit verschillende uitgangspunten. Agentforce is native verweven met het Salesforce-platform: data, metadata, beveiliging en automatisering zitten in dezelfde omgeving als waar de agent draait. Voor service-intensieve en asset-intensieve organisaties die hun klant-, order- en serviceprocessen al op Salesforce hebben, betekent dat minder integratiewerk en grounding op data die al in het platform leeft. Microsoft Copilot Studio is sterker verankerd in het Microsoft 365- en Azure-ecosysteem.

De keuze hangt dus vooral af van waar je kerndata en processen al staan, niet van een abstracte feature-vergelijking. Voor organisaties met de installed base, servicecontracten en facturatie op Salesforce ligt grounding op die data, en daarmee Agentforce, het meest voor de hand.

De commerciele modellen veranderen snel en verschillen per editie, regio en verbruik. We nemen hier bewust geen prijzen op die snel verouderen. In een intake brengen we eerst je use-case, datalandschap en volumes in kaart, en pas daarna de kosten, zodat een agent een verdedigbare businesscase heeft in plaats van een open einde.

Wat is Agentic Engineering?

Agentic Engineering is de discipline van het ontwerpen, bouwen, testen, uitrollen en beheren van AI-agents en headless-componenten als productieklare software. Op Salesforce heeft dit twee kanten: AI-coding-agents zoals Claude Code en OpenAI Codex die helpen sneller en betrouwbaarder op Salesforce DX en metadata te bouwen, en runtime-agents in Agentforce die gegrond worden in Data Cloud en beveiligd met de Einstein Trust Layer. Het verdiept Salesforce, het vervangt het niet: Salesforce blijft de kern en het system-of-record.

Hoe gebruikt Outbirds Claude Code en Codex bij Salesforce-ontwikkeling?

Outbirds zet MCP-compatibele AI-coding-agents zoals Claude Code, OpenAI Codex, Cursor en Windsurf in om Agentforce-agents, Apex, Flows, Lightning-componenten en headless-koppelingen te bouwen. Via de Salesforce DX MCP Server en Headless 360 bevragen de agents objectschema’s, schrijven en wijzigen ze code en metadata, draaien ze tests en deployen ze, in jouw eigen omgeving. We werken sandbox-first of scratch-first, met een least-privilege integration user, org-allowlisting (–orgs) en selectieve tools (–tools).

Is Agentforce veilig met onze data en AVG/GDPR?

Runtime-agents in Agentforce worden beveiligd via de Einstein Trust Layer: zero data retention (externe modellen bewaren je data niet), dynamic grounding op verifieerbare data uit Data Cloud om hallucinaties te beperken, data masking, toxiciteitsdetectie en audit logging. De agent erft de identiteit, sharing rules, field-level security en governor limits van de org. In combinatie met het Salesforce-beveiligingsmodel vormt dit de technische basis voor AVG- en GDPR-conform werken, al blijven de juiste inrichting en dataclassificatie mensenwerk.

Gaat onze klantdata naar het AI-model als jullie met AI-coding-agents bouwen?

Nee, dat is niet de bedoeling en we richten het zo in. De AI-coding-agents werken primair op broncode, metadata en configuratie, en we werken sandbox-first of scratch-first, waarbij een scratch org per definitie geen productiedata of metadata bevat. Klantdata blijft in de Salesforce-org. Tegelijk kunnen de Headless 360- en MCP-tools technisch ook SOQL, DML en export uitvoeren en tegen productie draaien, dus we perken dat bewust in met een least-privilege integration user, org-allowlisting en selectieve tools, en met eigen quality gates en review.

Wat is de Atlas Reasoning Engine?

De Atlas Reasoning Engine is het redeneerhart van Agentforce. Hij begrijpt eerst de intentie en scope van een vraag, bepaalt welke data en acties nodig zijn, en voert die acties vervolgens autonoom uit. Hij stuurt op Topics (de jobs-to-be-done), Instructions (guardrails in natuurlijke taal) en Actions (de concrete handelingen, achterliggend Flows, Apex of integraties).

Hoe bouw en beheer je een AI-agent in Salesforce?

Via een herhaalbare lifecycle: ontwerpen (Topics, Instructions en Actions in Agent Builder, met achterliggende Flows en Apex vaak gebouwd met AI-coding-agents in een sandbox of scratch org), gronden in Data Cloud op schone data, testen in het Agentforce Testing Center, uitrollen van sandbox naar productie via een DevOps-proces met versiebeheer en deploy-gates, en monitoren via de Trust Layer. Deze cyclus maakt het mogelijk een agent veilig te blijven verbeteren zonder regressie.

Vervangt agentic of headless Salesforce ons bestaande platform?

Nee. Headless en agentic zijn manieren om Salesforce dieper in te zetten, geen vervanging. Je datamodel, automatisering, security en governance blijven in Salesforce, dat de single source of truth blijft. AI-coding-agents bouwen op je eigen metadata en code, en runtime-agents in Agentforce draaien op het platform met de bestaande sharing rules en de Einstein Trust Layer.