Tools¶
Een tool is wat een agent kan doen: een API aanroepen, een pagina ophalen, code uitvoeren, in kennis zoeken of werk doorgeven aan een andere agent. Het model kiest of het een tool gebruikt en met welke argumenten. Core voert de tool uit en toetst elke aanroep aan de policy van de sleutel.
Tools komen uit verschillende bronnen. Voor het model zien ze er allemaal hetzelfde uit: een naam, een omschrijving en een schema voor de argumenten.
Waar tools vandaan komen¶
| Bron | Wat het is | Naam van de tool |
|---|---|---|
| Functietool | een tool die je eigen applicatie uitvoert. Je beschrijft hem op het verzoek; Core geeft de aanroep aan je terug en jij stuurt het resultaat in | de naam die je zelf kiest |
| API-koppeling | een eigen HTTP-endpoint dat Core aanroept met de argumenten van het model | api__<koppeling> |
| Script | een eigen programma, in Python of Node, dat Core in een sandbox draait met de argumenten van het model | script__<naam> |
| Functie (WebAssembly) | eigen deterministische code, gecompileerd naar WebAssembly, die Core binnen Core draait met de argumenten van het model: een prijs, een staffel, een controle | function__<naam> |
| MCP-server | een server die zelf tools aanbiedt. Core leest de toollijst en biedt de tools aan die je toestaat | mcp__<server>__<tool> |
| SQL-koppeling | een vaste eigen query op je database (Postgres, MySQL, SQL Server of Oracle), ingevuld met de argumenten van het model | sql__<koppeling> |
| Mailkoppeling | een mailbox van je organisatie of van de persoon voor wie de beurt is: zoeken, lezen, markeren, verplaatsen, een concept maken en versturen | mail__<koppeling>__<operatie> |
| Ingebouwde tools | tools van Core zelf, per sleutel aangezet: een pagina ophalen, zoeken op het web, een heel document lezen, een document schrijven, een afbeelding genereren, een opname transcriberen, code uitvoeren op een computer, een subagent | builtin__<naam> |
| Artific Connect | kant-en-klare bundels voor bekende diensten, zoals GitHub, Slack, Microsoft en AFAS. Je installeert er een vanaf de Marktplaats en krijgt een toolset | de naam van de toolset, zoals github |
| Agent als tool | een andere agent van je organisatie, die het model als één tool aanroept | agent__<naam> |
| Workflow als tool | een van je workflows, die het model start en waarvan het hoort wanneer hij klaar is | workflow__<naam> |
| Zoektool | een zoekopdracht over kennis | knowledge__<naam> |
| Datastores en geheugen | records lezen en schrijven in een datastore; geheugen doorzoeken en schrijven | datastore__<id>__..., memory__<index-id>__... |
| Core zelf | één operatie van de API van Core, zoals een skill opslaan (MCP) | core__<tool> |
| Alias | je eigen tweede naam voor een van de tools hierboven, voor één context | alias__<naam> |
Een tool kan ook aanroepvariabelen declareren: waarden zoals het account waarvoor een aanroep
is, die je applicatie met het verzoek meestuurt in tool_variables en die het model nooit ziet of
kiest.
Een script zit tussen een API-koppeling en de computer-tools in. Net als een koppeling is het één tool met een vaste naam, een omschrijving en een schema voor de argumenten, zodat policy, verbruik en prijzen het kunnen noemen. Net als de computer-tools draait het code in een afgeschermde sandbox zonder netwerk, op de eigen computer van de beurt; maar de code is van jou, één keer getest en geüpload met de bestanden die hij nodig heeft, en het model kan hem niet lezen of veranderen. Het model roept het aan met argumenten en krijgt de uitvoer en de bestanden terug die het programma maakte.
Een functie is voor wat een model nooit mag beslissen: een prijs in een staffel, een
minimumbestelling, een btw-verdeling. Een functie is één tool met een naam, een omschrijving en
schema's voor de argumenten en het antwoord, net als een script, maar draait binnen Core in
milliseconden in plaats van op een computer, en hij roept nooit iets buiten zichzelf aan: geen klok,
geen toeval, geen netwerk, geen bestanden. Hij leest zijn argumenten en de datastore-records die
zijn versie declareert, die Core als de aanroeper voor hem leest, en verandert records alleen door
schrijfacties terug te geven die Core in één keer uitvoert, gebonden aan wat hij las. Dezelfde
invoer geeft dus altijd hetzelfde antwoord, en elke aanroep wordt vastgelegd met vingerafdrukken van
wat erin ging en wat eruit kwam. Een functie heeft tooling nodig, en datastores als hij
datastores leest of schrijft. Het is iets anders dan de functietool hierboven, die je eigen
applicatie uitvoert. Functies schrijf je alleen via de API, zoals Functies via de
API laat zien; de console heeft er nog geen scherm voor.
Het voorvoegsel van de naam zegt dus waar een tool vandaan komt. GET /tools toont elke tool van je
organisatie, uit elke bron; het Overzicht onder Tools in de console toont ze per soort.
Wanneer gebruik je welke bron¶
| Je wilt | Gebruik |
|---|---|
| iets doen wat alleen je eigen applicatie kan, zoals een scherm bijwerken | een functietool |
| een bestaande HTTP-API beschikbaar maken, met een credential die Core bewaart | een API-koppeling |
| een systeem aansluiten dat al een MCP-server heeft | een MCP-server |
| het model gegevens uit je eigen database laten lezen of er een rij in laten schrijven | een SQL-koppeling |
| het model een mailbox laten lezen of er mail mee laten versturen | een mailkoppeling |
| een bekende dienst aansluiten zonder zelf een koppeling te bouwen | Artific Connect |
| het model laten zoeken in je eigen documenten | een zoektool |
| het model een eigen, getest programma laten draaien, zoals een presentatie in huisstijl | een script |
| een prijs, een staffel of een controle berekenen die het model niet mag beslissen | een functie |
| het model vrij laten rekenen, een bestand verwerken of code testen; voor een exact getal waar je bedrijf op rust, gebruik een functie | de computer-tools |
| een deeltaak overlaten aan een gespecialiseerde agent | een agent als tool |
Toolsets¶
Een toolset is een naam voor een groep tools uit elke bron. Een verzoek of een agent noemt de
set in plaats van elke tool. Een toolset bevat patronen, zoals api__*, dus een tool die je later
registreert en die bij het patroon past, zit er vanzelf in. Elke geregistreerde MCP-server is ook
een toolset van haar eigen tools.
Een toolset is een manier van groeperen en geeft geen extra rechten. Elke tool in de set wordt getoetst aan de policy van de sleutel.
Eén beurt draagt hooguit 128 tools, de tools van elke toolset en elke agent meegeteld, en minder als het model minder aankan. Bied aan wat de taak nodig heeft: een lange lijst kost het model bovendien budget voordat het je invoer leest. Een agent die meer nodig heeft, zet ze achter de toolrouter, die het model twee tools geeft om de rest te zoeken en uit te voeren.
Wie welke tool mag gebruiken¶
Drie dingen moeten kloppen voordat een model een tool krijgt aangeboden:
- De capability. API-koppelingen, MCP-tools, scripts en ingebouwde tools vereisen
tooling. Zoektools vereisenknowledge, geheugentoolsmemory, en de computer-tools en scripts ookcomputer. - De systeemtools van de sleutel. Elke ingebouwde tool staat uit tot je hem op de sleutel aanvinkt. Een script heeft geen systeemtool nodig.
- De policy. Regels over Tools bepalen welke namen de sleutel mag aanroepen. Een tool
waarvan geen regel het gebruik (
use) toestaat, valt uit de beurt. Voor een verzoek dat een persoon noemt, bepalen dezelfde regels ook welke koppelingen, MCP-servers, scripts, zoektools en toolsets de lijsten van de sleutel tonen (Registraties).
Een tool die Core voor je aanroept, stuurt gegevens naar een host buiten Core. Welke hosts dat mogen zijn, bepaalt de organisatie zelf met haar lijst Toegestane hosts; een sleutel kan die lijst versmallen (Toegestane bestemmingen).
Het resultaat van een tool is informatie voor het model en nooit een instructie. Met de capability
trust_envelope vertelt Core het model uitdrukkelijk welke tekst gegevens zijn
(Vertrouwen in toolresultaten).
Hoe het samenhangt¶
- Een agent legt vast welke tools en toolsets hij meebrengt; een verzoek kan er tools aan toevoegen.
- Kennis bereikt een model via een zoektool, en dat is een tool als elke andere.
- MCP is één van de manieren om tools aan te sluiten, en ook een manier om je tools aan een client buiten Core aan te bieden.
- Elke toolaanroep die Core uitvoert, wordt gemeten als verbruik en staat in de trace van de beurt (Inzicht).
- Toolsets, API-koppelingen, SQL-koppelingen en MCP-servers kunnen in een publicatie; een mailkoppeling niet.
- Een API-koppeling, een SQL-koppeling, de tools van een MCP-server en een agent die als tool wordt aangeboden, kunnen als taak draaien: het model start de aanroep, gaat door met het gesprek en leest het resultaat zodra het er is (Een tool op de achtergrond draaien).
- Een API-koppeling, een SQL-koppeling, een MCP-server, een script, een workflow en een alias kunnen per verzoek een waarde van je applicatie krijgen, een aanroepvariabele, zoals het account-id van je klant of, bij een API-koppeling of MCP-server, zijn eigen token. Het model ziet die waarde nooit. Scripts, workflows en aliassen accepteren geen geheime (Een waarde van je klant aan een tool meegeven).
Verder¶
Tutorial: Laat een agent een actie uitvoeren met een tool.
| Onderdeel | Lees |
|---|---|
| Tools op een verzoek, alle bronnen via de API | Tools via de API |
| Het overzicht van tools, toolsets en systeemtools | Tools in de console |
| API-koppelingen | API-koppelingen in de console |
| MCP-servers | MCP-servers in de console |
| Waarden per verzoek | Een waarde van je klant aan een tool meegeven |
| SQL-koppelingen | SQL-koppelingen via de API |
| Mailkoppelingen | Mailkoppelingen via de API |
| Computers | Computers via de API, Computers in de console |
| Scripts | Scripts via de API, Scripts in de console, Een script lokaal testen, Wat de sandbox-image meebrengt |
| Tools die doorlopen na de beurt | Een tool op de achtergrond draaien |
| Veel tools achter twee | De toolrouter, Een agent met veel tools |
| Agent als tool | Een agent als tool aan een beurt geven |
| Artific Connect | Marktplaats en de pagina's onder Referentie, zoals GitHub |
| Datastores als tool | Een datastore gebruiken vanuit een agent |