2026-03-24 · Bijgewerkt 2026-07-14

[!NOTE] Automatische vertaling Dit artikel is automatisch vertaald vanuit de oorspronkelijke Engelse versie.

AI Agent Tool Use in 2026: MCP, CLI, vaardigheden en uitvoering van code

Deel 3 van de serie ‘Engineering the Agentic Stack’

Deel 1 loopt door reasoning-loopen heen, en Deel 2 Gecoverde geheugen. Dit artikel voegt de actielayer toe: hoe een agent hulpmiddelen exposeert, selecteert en uitvoert.

Het verhaal rondom de hulpmiddelen veranderde in 2025–2026. MCP bood leveranciers een gedeelde protocollenafwijzing voor externe diensten, terwijl code-uitvoerende agents aantoonde dat een model soms een klein programma efficiënter kan samenstellen dan door een lange reeks JSON aanroepen. Anthropic rapporteerde een 98,7% token daling in de kosten voor een bepaalde uitgavenanalyse workflow, en het artikel over CodeAct meldde winsten van tot wel 20% binnen hun benchmark configuratie. Deze resultaten beschrijven hun specifieke taken en tools, en geven geen universele voordelen voor code-uitvoering weer.

Ik vergelijk de oproep van het JSON-hulpprogramma, MCP, vaardigheden, CLI-hulpprogramma’s en de uitvoering van code in die volgorde. In het laatste gedeelte worden de ontwerpprincipes voor een Agent-computerinterface (ACI) toegepast op Marktanalist Agent.

TL;DR: Vijf nuttige interfacepatronen dekken het grootste deel van agent tool use. Skills dragen instructies over, CLI-hulpmiddelen zijn geschikt voor lokaal ontwikkelen, MCP verbindt gedeelde diensten met elkaar, en uitvoering van code zorgt voor het samenstellen van meerdere stappen binnen een sandbox. Het gebruik van een JSON-hulpmiddel blijft de eenvoudigste optie voor kleine, atomaire acties. Ongeacht het protocol moet de Agent-Computer Interface (ACI) ervoor zorgen dat acties duidelijk zijn, feedback compact wordt weergegeven en fouten hersteld kunnen worden.

Vijf manieren waarop AI agents tools gebruikt

In Deel 1, De reasoning loop heeft de volgende stap gekozen. Deel 2 Het wordt de benodigde staat opgeslagen om het proces weer te kunnen voortzetten. De grens van het hulpprogramma zet deze beslissing om in een actie en stuurt een observatie terug naar de lus. Deze vijf patronen leiden tot verschillende afwegingen met betrekking tot de kosten, flexibiliteit en doorvoerbaarheid van token.

1. Oproep van het JSON-hulpprogramma: de basislijn

Het oorspronkelijke patroon: u definieert tool schemas als JSON, waarna de LLM gestructureerde functieaanroepen genereert die uw code vervolgens uitvoert. Dit is goed begrepen en werkt uitstekend voor kleine sets hulpprogramma’s.

# Traditional tool definition — each tool consumes ~550-1,400 tokens (Apideck benchmark)
tools = [
    {
        "name": "get_stock_price",
        "description": "Get the current stock price for a ticker symbol",
        "input_schema": {
            "type": "object",
            "properties": {
                "ticker": {"type": "string", "description": "Stock ticker (e.g., NVDA)"}
            },
            "required": ["ticker"]
        }
    }
]

Met 5-10 tools is dit acceptabel. Het probleem ligt bij de schaal: elke definitie van een tool heeft kosten. 550-1,400 tokens. Met 20 tools besteed je al 15-25K tokens voordat de agent zelfs maar begint reasoning.

2. MCP voor gedeelde integraties

Het Model Context Protocol vormt de standaard waaraan de meeste leveranciers zich hebben aangepast. Anthropic heeft dit protocol in december 2025 geschonken aan de Linux Foundation onder de Agentic AI Foundation (AAIF), samen met OpenAI en Block, met steun van Google, Microsoft en AWS als platinelidmaatschappen. OpenAI heeft MCP-ondersteuning toegevoegd aan zijn Responses API. Op dit moment zijn er meer dan 10.000 actieve MCP servers en meer dan 97 miljoen maandelijkse SDK downloads.

MCP is geschikt voor integraties tussen verschillende SaaS-aanbieders (zoals Figma, Notion en Salesforce), diensten die geen CLI-equivalenten hebben, en omgevingen die OAuth orchestration nodig hebben. De waarde ervan ligt in een gedeelde ontdekkingsslaag en transportlaag. Beheer blijft afhankelijk van de authenticatie, autorisatie, logging en deployment-controle van de server.

Het verhaal achter de productie is rommeliger dan de cijfers in de koppen doen vermoeden.

De beveiligingsoppervlakte vormt het eerste probleem. De Een kwetsbaar MCP project Houdt 50 kwetsbaarheden in de MCP-servers in de gaten, waarvan 13 als kritiek worden geclassificeerd; deze zijn gemeld door 32 beveiligingsonderzoekers. De aanvalscategorieën omvatten span prompt injection, fouten bij invoervalidatie, authenticatiefouten en netwerkbeveiligingsproblemen. Het eerste echte kwaadaardige MCP-server in de praktijk verscheen in september 2025: een pakket genaamd postmark-mcp dat elke verstuurd e-mail naar het adres van de aanvaller via BCC werd gestuurd, waardoor schattingen zijn dat 300–500 organisaties werden getroffen voordat dit ontdekt werd.

Tool poisoning is de aanvalsvorm die mij het meest zorgen baart. Invariant Labs heeft dit gedemonstreerd Die vergiftigde MCP-tools kunnen gegevens ontslepen, zelfs wanneer ze nooit worden opgeroepen. Het model is al voldoende om de aanval in gang te zetten door enkel de metadata van het tool te lezen. MCPTox benchmarks Bij het testen van 20 LLM agents op 45 echte MCP servers, werd een succesratio van aanvallen vastgesteld die oploopt tot maar liefst 72,8%.

Token overhead vormt het operationele probleem. Een team dat MCP servers beheert voor GitHub, Slack en Sentry (in totaal ongeveer 40 tools) stuitte op dit probleem. 55,000 tokens van schema-definities die worden ingevoegd voordat een gebruiker iets vraagt. Een andere gemelde 143.000 van de 200.000 beschikbare tokens (72%) Uitsluitend verbruikt door de definities van de tools zelf.

Anthropic meldde een vermindering van 85% in het aantal schema’s voor zijn Tool Search Tool, en een vermindering van 96% wanneer er drie tot vijf relevante tools worden geladen voor de geëvalueerde taken. Door selectief te laden blijft het benodigde protocoloppervlak behouden, terwijl de schema’s die de huidige vraag niet nodig heeft worden verwijderd.

3. Expertise in het skillspakket, niet de uitvoering

Eind 2025 werd de standaardisatie van agent-vaardigheden als open formaat ingevoerd (geïntroduceerd in oktober 2025 en gepubliceerd als open standaard in december 2025). Dit onderscheid is belangrijk: tools bieden functionaliteiten (wat agents kan doen), terwijl vaardigheden expertise opleveren (wat agents weet over de manier om complexe taken uit te voeren).

De SKILL.md-standaard definieert een vaardigheid als een markdown-bestand met YAML frontmatter:

---
name: deploy
description: Deploy the application to production
argument-hint: "[environment]"
user-invocable: true
---
Deploy the application to the $0 environment (default: staging).
Steps:
1. Run the test suite
2. Build the production bundle
3. Deploy using the deploy script
4. Verify the deployment health check

Vaardigheden maken gebruik van progressieve onthulling. Ongeveer 100 tokens aan metadata wordt bij het opstarten geladen; de volledige instructies worden pas geladen wanneer de vaardigheid actief is. Daarentegen kunnen ongeveer 40 MCP hulpmiddelen gegevens verbruiken ongeveer 55.000 tokens Voor het begin van reasoning. Tegen maart 2026 hadden Claude Code, OpenAI Codex CLI, Cursor, GitHub Copilot, Gemini CLI, Goose, Windsurf en Roo Code dit formaat al overgenomen. Victor Dibia beschrijft deze verschuiving. in de richting van door code aangestuurde agent acties.

Maak gebruik van deze vaardigheden voor domeinkennis, meervoudige stappenprocedures en herhalende taken zoals database-migraties of betalingsintegraties. Ze zijn geschikt voor taken waarbij de agent instructies nodig heeft over hoe een bestaande functionaliteit moet worden gebruikt.

4. CLI- en shellhulpmiddelen

CLI-interfaces kunnen in veel gevallen goedkoper zijn wanneer de model de opdracht al kent. Scalekit rapporteerde een 4-32x token verschil tussen zijn CLI en MCP-paden gedurende 75 uitvoeringen. Die casestudy meet de tools en taken ervan; deze vervangt echter geen vergelijking met uw eigen manifesten en commando-uitvoer.

Alom gedocumenteerde commando’s zoals git, docker, kubectl, gh, curl, en jq Vaak is er weinig introductietekst voor het schema nodig. Minder gebruikelijke of interne CLI’s hebben desondanks nog steeds toegankelijke hulpmateriaal, voorbeelden en stabiele, door machines leesbare uitvoer nodig.

De gids van Ugo Enyioha “CLI-tools schrijven die AI Agents echt gebruikt willen worden” Acht geformaliseerde ontwerprules:

1. Structured output is verplicht — ondersteuning --json
2. Exitcodes vormen onderdeel van de controlestroom — gebruik aparte codes voor verschillende fouttypen
3. Commando’s moeten idempotent zijn
4. Zelfdocumenterend --help met realistische voorbeelden
5. Ontwerp voor componabiliteit — --quiet Voor brute waarden: ondersteuning voor stdin
6. Geef --dry-run en --yes flags
7. Steun voor introspectie van de versie
8. Authenticatie afhandelen via omgevingsvariabelen

De compromissen zijn reëel. De CLI mist de typeveiligheid van MCP, ingebouwde OAuth orchestration-functionaliteit, hulpprogrammaontdekking en een audittrail. Het patroon dat ik bij de meeste teams zie, is dat de CLI wordt gebruikt als standaard voor ontwikkeling en lokale operaties, terwijl MCP wordt ingezet voor integratie met externe diensten en bedrijfsbeheer.

5. Codeuitvoering voor meerdere stappenwerkzaamheden

Dit is de verandering in de agent-tooling die ik als het meest significante beschouw. In plaats van dat de LLM gestructureerde JSON-data uitzendt om vooraf gedefinieerde functies één voor één aan te roepen, genereert de agent een volledige Python- of bash-script die meerdere hulpprogramma’s oproept, resultaten verwerkt met lussen en conditionele instructies, en uitsluitend de eindsamenvattingen teruggeeft naar de model-omgeving.

Anthropic heeft dit geformaliseerd met Programmatische hulpprogramma-aanroep (PTC), Nu is GA beschikbaar in Claude API. De academische basis vormt… CodeAct-paper (Wang et al., ICML 2024), die onderzoek deden met 17 LLMs en ontdekten dat code‑acties leidden tot een 20% hogere succesratio bij het uitvoeren van taken en 30% minder stappen vergeleken met alternatieven gebaseerd op JSON.

Drie casestudy’s van eerste-partij gebruikers tonen aan waar dit patroon van nut kan zijn. Beschouw ze als bewijsmateriaal van de leverancier en voer de vergelijking opnieuw uit bij uw eigen taken.

• Vercel heeft hun d0-text-naar-SQL-converter opnieuw gebouwd agent door 80% van de tools te verwijderen (van 15 naar 2): ExecuteCommand en ExecuteSQL). De succesratio van de taak steeg van 80% naar 100%, de uitvoeringsduur daalde met een factor 3,5 en het gebruik van token nam af met 40%. Hun formulering: “De beste agents zijn waarschijnlijk die met het minste aantal hulpmiddelen.”

• Cloudflare heeft “Code Mode” ontwikkeld, Het is mogelijk om agents te laten TypeScript schrijven zodat deze hun API kan aanroepen in plaats van tool schemas te definiëren, waardoor de contextbelasting wordt verminderd. Hun reasoning luidt: “LLMs bevat een enorme hoeveelheid echte TypeScript-code in hun trainingsset, maar slechts een klein aantal kunstmatig gemaakte voorbeelden van tool calls.”

Hier is het patroon van De documentatie van Anthropic over PTC. Traditionele hulpmiddelen die een uitgavenanalyse vereisen, hebben nodig aan 20+ afzonderlijke inference oproepen, één per teamlid, waarbij alle tussentijdse gegevens via de context worden verwerkt. Een workflow die ongeveer 150.000 tokens verbruikt bij directe hulpmiddeloproepen, is opnieuw geimplementeerd voor ongeveer 2.000 tokens, wat resulteert in een 98,7% daling van het verbruik. Met codeuitvoering genereert de agent slechts één script:

# Agent generates this code, executes in sandbox
import json
members = get_team_members("engineering")
over_budget = []
for m in members:
    expenses = get_expenses(m["id"], "Q3")
    total = sum(e["amount"] for e in expenses)
    if total > 5000:
        custom = get_custom_budget(m["id"])
        limit = custom["limit"] if custom else 5000
        if total > limit:
            over_budget.append({"name": m["name"], "spent": total, "limit": limit})
# Only this final summary returns to the LLM context
print(json.dumps(over_budget))

De LLM ziet alleen de eind JSON samenvatting, en niet de duizenden uitgavenposten die in de sandbox worden verwerkt. Dankzij de Token efficiëntie, de ingebouwde compositibiliteit (lussen en conditionele constructies zijn standaard beschikbaar) en een echte foutbehandeling.try/except In plaats van natuurstaal reasoning met betrekking tot fouten, en privacy (gevoelige gegevens blijven binnen de sandbox), verbeteren al deze aspecten tegelijkertijd.

Wanneer het nog zinvol is om een JSON-tool te gebruiken, zijn dat situaties met enkele atomaire operaties, omgevingen zonder sandboxing-infrastructuur, kleinere models-systemen met zwakke codegeneratie, of auditvereisten waarbij elke afzonderlijke oproep van een tool geregistreerd moet worden.

AI agent Vergelijkings tabel voor het aanroepen van tools

Composabiliteit duidt hier op de gemakkelijkheid waarmee meerdere operaties in een grotere workflow kunnen worden opgeregen. Een lage waarde betekent dat elke tool call doorgaans nog een extra model heen-en-weerreis vereist; een hoge waarde betekent dat de interface tussentijdse resultaten kan doorgeven via pijpen, variabelen of procedurele stappen. Token en de cellen met taakresultaten vatten de genoemde voorbeelden samen, in plaats van één gecoördineerde benchmark voor alle vijf kolommen.

De Agent-computerinterface (ACI) voor AI agent-hulpmiddelen

De term “Agent-Computer Interface” (ACI) werd bedacht door John Yang, Carlos E. Jimenez en hun collega’s aan Princeton in hun SWE-artikel over agent (NeurIPS 2024). Het concept is eenvoudig: net zoals mensen profiteren van goed ontworpen interfaces (HCI), zijn LM agents “een nieuwe categorie eindgebruikers met hun eigen behoeften en mogelijkheden, die ook baat zouden hebben bij speciaal ontworpen interfaces.”

De Ablatie-resultaten Ik heb dit gereserveerd. De SWE-agent met zijn volledige ACI behaalde 18,0% op de SWE-bench Lite, vergeleken met 7,3% wanneer alleen een standaard Linux-shell werd gebruikt – dat is een verbetering van 10,7 procentpunt alleen al door het interfaceontwerp. Het guardrail-proces zorgde op zichzelf voor nog eens 3 procentpunt: 51,7% van de agent-aanpassingen bevatte ten minste één fout die door de linter werd opgemerkt voordat deze verder kon verspreiden.

Anthropic heeft ACI aangenomen als fundamenteel concept in hun Het ontwikkelen van effectieve Agents Gids, waarin dit wordt opgenomen als een van de drie kernprincipes: “Ontwerp uw agent-computergebruikersinterface zorgvuldig door middel van uitgebreide documentatie en testing van de tools.” Hun praktische richtlijn luidt: “Een handige regel is om na te gaan hoeveel moeite er in mens-computergebruikersinterfaces wordt gestoken, en om evenveel inspanning te plannen voor het creëren van goede agent-computergebruikersinterfaces.”

Vier principes van ACI in de praktijk

1. Acties moeten eenvoudig en gemakkelijk te begrijpen zijn. De meest voorkomende fout is het één-op-één omhullen van API-endspunten. In plaats daarvan list_users, list_events, create_event, implementeren schedule_event dat beschikbaarheid bepaalt en een planning maakt in één oproep. In plaats van read_logs, implementeren search_logs die alleen de relevante regels teruggeeft, samen met de context.

2. Acties moeten compact en efficiënt zijn. Consolideer belangrijke operaties tot zo weinig acties mogelijk. In de Marktanalist Agent, Ik combineer het ophalen van prijzen met basismetrieken tot één geheel. get_stock_snapshot een tool in plaats van het nodig hebben van afzonderlijke aanroepen voor de prijs, het volume, de marktkapitalisatie en de PE-verhouding.

3. Feedback over de omgeving moet informatief zijn, maar wel beknopt. Vermijd het terugsturen van ruwe HTML-inhoud of volledige API-pakketten. Zorg ervoor dat cryptische ID’s worden omgezet in semantische namen. De testen van Anthropic toonde aan dat het toevoegen van een response_format enum die agents in staat stelt om beknopte (~72 tokens) of gedetailleerde (~206 tokens) responses aan te vragen (met een kostenverschil van 3x token), heeft de prestaties in de praktijk aanzienlijk verbeterd.

4. Guardrails moet de verspreiding van fouten beperken. Automatische foutdetectie helpt agents om fouten snel te herkennen en te corrigeren. In SWE-agent, Een aangepaste bestandbewerker met geïntegreerde linting wijst syntaxisfouten automatisch af, waardoor 51,7% van de agent bewerkingss fouten al wordt opgepakt voordat deze zich kunnen verergeren. Ik pas hetzelfde principe toe in de Market Analyst Agent door de argumenten van de tools vóór uitvoering te valideren met Pydantic-schemas:

from pydantic import BaseModel, Field, field_validator

class StockQuery(BaseModel):
    """Validated input for stock queries.

    Pydantic catches malformed tickers before the API call,
    preventing error propagation through the reasoning loop.
    """
    ticker: str = Field(description="Stock ticker symbol (e.g., NVDA)")
    period: str = Field(default="1mo", description="Time period: 1d, 5d, 1mo, 3mo, 1y")

    @field_validator("ticker")
    @classmethod
    def validate_ticker(cls, v: str) -> str:
        v = v.upper().strip()
        if not v.isalpha() or len(v) > 5:
            raise ValueError(f"Invalid ticker format: {v}")
        return v

    @field_validator("period")
    @classmethod
    def validate_period(cls, v: str) -> str:
        valid = {"1d", "5d", "1mo", "3mo", "6mo", "1y", "5y"}
        if v not in valid:
            raise ValueError(f"Invalid period: {v}. Must be one of {valid}")
        return v

AI agent ontwerppatronen voor tools die effectief werken

Anthropic’s “Het schrijven van effectieve hulpmiddelen voor agents” Guide frames presenteert tools als “een nieuw type software dat een contract weerspiegelt tussen deterministische systemen en niet-deterministische agents.” Hieronder staan de patronen die zijn geformuleerd op basis van praktijkervaring in productieomgevingen.

Beschouw de beschrijvingen van tools als prompt engineering

De beschrijvingen moeten worden weergegeven. Er moet minimaal 3 tot 4 zinnen in de vertaling staan. De technische specificaties van het agentmodel moeten nauwkeurig worden weergegeven om garantie te bieden voor correcte functionele prestaties onder verschillende workloads. Omdat de integratie met bestaande infrastructuur cruciaal is, moet de compatibiliteit met de huidige protocollen zorgvuldig worden getest voordat het systeem in productie wordt geplaatst. Alle configuratieparameters moeten volgens de standaardrichtlijnen worden geoptimaliseerd om, Uitleg over wanneer het hulpmiddel moet worden gebruikt, vereiste versus optionele parameters, uitvoerformat en randgevallen. Naamruimtebeheer met prefixenasana_search, jira_searchDit heeft “niet-triviale effecten” op de nauwkeurigheid van de keuze van hulpmiddelen. In de experimenten van Anthropic presteerden de door Claude geoptimaliseerde beschrijvingen van hulpmiddelen beter dan die door experts handgeschreven waren, volgens de evaluatie benchmarks.

# Bad: vague, no context for when to use
tools = [{
    "name": "search",
    "description": "Search for items",
}]

# Good: specific, with input examples and edge cases
tools = [{
    "name": "stock_search_news",
    "description": (
        "Search for recent news articles about a specific stock or company. "
        "Use this tool when the user asks about recent events, earnings, "
        "announcements, or market-moving news for a specific ticker. "
        "Returns up to 10 articles sorted by relevance. "
        "For broad market news (not ticker-specific), use market_overview instead."
    ),
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "Search query. Examples: 'NVDA earnings Q3 2025', 'Tesla delivery numbers'"
            },
            "max_results": {
                "type": "integer",
                "description": "Max articles to return (1-10, default 5)",
                "default": 5
            }
        },
        "required": ["query"]
    }
}]

Interne testing bleek dat de invoervoorbeelden (input_examples (field) heeft de nauwkeurigheid bij het verwerken van complexe parameters aanzienlijk verbeterd.

Geef een hoge-signaalsterkte, door machines leesbare uitvoer terug

Vermijd identificatoren op lage niveau.uuid, mime_type). Zorg ervoor dat cryptische ID’s worden omgezet in semantische namen. Structureer het antwoord zodat agent erover kan nadenken zonder dat er onnodige boilerplate moet worden geanalyseerd:

# Bad: raw API response dumped to agent
def get_stock_price(ticker: str) -> dict:
    response = api.get(f"/v1/quotes/{ticker}")
    return response.json()  # 500+ tokens of nested JSON

# Good: high-signal summary the agent can immediately reason about
def get_stock_price(ticker: str) -> dict:
    data = api.get(f"/v1/quotes/{ticker}").json()
    return {
        "ticker": ticker,
        "price": data["regularMarketPrice"],
        "change_pct": round(data["regularMarketChangePercent"], 2),
        "volume": data["regularMarketVolume"],
        "market_cap_b": round(data["marketCap"] / 1e9, 1),
        "pe_ratio": data.get("trailingPE"),
        "summary": f"{ticker} at ${data['regularMarketPrice']:.2f} "
                   f"({'up' if data['regularMarketChangePercent'] > 0 else 'down'} "
                   f"{abs(data['regularMarketChangePercent']):.1f}%)"
    }

Fouten retourneren waarmee de lus kan worden verwerkt

Gebruik vier afzonderlijke mechanismen omdat ze verschillende klassen fouten afhandelen:

1. Probeer opnieuw met exponentiële backoff bij tijdelijke fouten.
2. Model-fallbackketens voor uitval van providers.
3. Classificatie van fouten routing — bij tijdelijke fouten wordt herproberd, bij LLM-herstelbare fouten wordt er met context naar de agent geretourneerd, en fouten die menselijke interventie vereisen, worden verder geëscaleerd.
4. Checkpoint-herstel om te zorgen dat de dienst na een crash blijft functioneren.

De geciteerde Anthropic-gids ondersteunt duidelijke foutmeldingen van tools en een op evaluatie gebaseerd ontwerp van tools. Ze stelt geen universele maatstaf voor het verlagen van het faleniveau vast; meet daarom zelf de herstelkans, het aantal pogingen en de escalatiemethoden voor jouw eigen reeks taken.

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=2, max=10),
)
def call_stock_api(ticker: str) -> dict:
    """Fetch stock data with automatic retry on transient failures.

    Layer 1: Exponential backoff handles rate limits and network blips.
    If all retries fail, the error propagates to the agent with
    enough context to decide whether to try a different approach.
    """
    response = httpx.get(
        f"https://api.example.com/v1/quotes/{ticker}",
        timeout=10.0,
    )
    response.raise_for_status()
    return response.json()

Toepassing van de patronen op de marktanalist Agent

De Marktanalist Agent van Deel 1 zorgt ervoor dat het effect van de interface zichtbaar wordt.

Consolidatie van tools

Het artikel in Deel 1 toont het vereenvoudigde oppervlak met 5 hulpmiddelen na deze refactor. Vóór die opmaakactie bevatte het oorspronkelijke ontwerp meer dan 10 hulpmiddelen: get_stock_price, get_company_metrics, get_market_cap, get_pe_ratio, get_volumeEnzovoort. Elk daarvan was een dunne omhulling rondom één API-endpoint. De agent moest bepalen welke combinatie er voor elke aanvraag moest worden geroepen.

Ik heb deze geconsolideerd tot 5 hoge‑level hulpmiddelen, in overeenstemming met het ACI‑principe van compacte, efficiënte acties:

Dit verminderde de overhead van tool schema aanzienlijk en zorgde er bovendien voor dat de keuze van hulpmiddelen door de agent betrouwbaarder werd, aangezien er minder dubbelzinnige opties meer zijn.

Structured outputs voor tool results

Elk hulpmiddel in de Market Analyst Agent geeft een door Pydantic gevalideerde respons terug. Dit past het ACI guardrails-principe toe aan de grens van het hulpmiddel:

class StockSnapshot(BaseModel):
    """Structured tool response — the agent never sees raw API noise."""
    ticker: str
    price: float
    change_pct: float
    volume: int
    market_cap_b: float
    pe_ratio: float | None
    summary: str  # Human-readable one-liner for direct use in reports

class NewsResult(BaseModel):
    """Each news item is pre-processed for agent consumption."""
    headline: str
    source: str
    date: str
    relevance_score: float  # Pre-ranked so the agent doesn't waste tokens sorting
    key_points: list[str]  # Extracted by the tool, not the agent

De summary Het veld is datgene wat het meest belangrijk is. Het levert de agent een direct bruikbare string op die zonder verdere verwerking rechtstreeks in een rapport kan worden opgenomen. key_points in NewsResult Ze worden aan de serverkant geëxtraheerd, waardoor agent beschermd blijft tegen het verbruik van inference tokens bij het parseren van artikelteksten.

Afwegingen en overwegingen

Naast de hierboven genoemde specifieke beperkingen per modaliteit, spelen er nog enkele algemene factoren een rol bij het maken van deze keuze:

• De operationele kosten verschillen per dimensie. Het uitvoeren van code bespaart tokens, maar zorgt voor extra sandbox cold-start latency-kosten. MCP verkort de ontwikkelingstijd voor SaaS-integraties, maar leidt tot meer serverlijke deployment-overhead. CLI is gratis om te starten, maar moeilijker te beheren op grote schaal. Optimaliseer op basis van uw eigen bottleneck, ongeacht of dat gaat om kosten van token, latency, of operationele complexiteit.

• Teamvaardigheden zijn van cruciaal belang. Bij de uitvoering van code wordt verondersteld dat uw agents (en de models die eraan ten grondslag liggen) in staat is om betrouwbare Python- of TypeScript-code te genereren. Voor CLI-workflows is kennis van Unix-conventies vereist. MCP vereist weer kennis van transportprotocollen en OAuth-workflows. Pas de benodigde werkwijze aan op de sterke punten van uw team.

• Het consolideren van tools kan te ver gaan. Wanneer één tool ongerelateerde modi en argumenten opstapelt, stuit de agent op een ander selectieprobleem binnen het schema. Gebruik evaluaties van toolselectie en taaksucces om de meest geschikte optie voor uw werklast te vinden.

• Vaardigheden zijn gebaseerd op prompt en worden niet afgedwongen. Een vaardigheid vertegenwoordigt instructies die de agent moet opvolgen, en niet dat deze guardrails altijd moet worden nageleefd. Voor kritieke workflows-situaties dient men vaardigheden te combineren met deterministische validatie.

• De vereisten voor audits bepalen de keuze. Als u een volledig log nodig heeft van elke oproep aan een tool en het resulterende resultaat, bieden de MCP en JSON tools standaard gestructureerde audittrail‑gegevens. Het uitvoeren van code genereert een script en diens uitvoer, wat nuttig is, maar moeilijker te ontleden in afzonderlijke acties voor rapportage over naleving.

Toolselectie op grotere schaal

Er zijn drie richtingen die het waard zijn om in de gaten te houden.

Het eerste voorbeeld is het hulpmiddel RAG voor schaling. Naarmate de set hulpmiddelen toeneemt tot honderden of duizenden, daalt de nauwkeurigheid van een eenvoudige selectiemethode voor hulpmiddelen tot 13,62%. MCP-RAG artikel Het bleek dat het toepassen van retrieval-versterkte generatie bij de selectie van hulpmiddelen (het indexeren van beschrijvingen van hulpmiddelen in een vector database en het ophalen alleen van relevante hulpmiddelen per zoekopdracht) een nauwkeurigheid oplevert van 43,13%, wat neerkomt op een verbetering met 3,2 keer, terwijl dit tegelijkertijd de prompt tokens met ongeveer 50% vermindert.

Het tweede voorbeeld is agents, waarbij ze hun eigen hulpmiddelen ontwikkelen. LATM framework “LLMs Als toolontwikkelaars”) hebben een tweefasig paradigma geïntroduceerd, waarbij een krachtige LLM herbruikbare Python-functies genereert en een lichtgewicht LLM deze functies gebruikt. ToolMaker (ACL 2025) transformeert op autonome manier GitHub-repo’s om tot tools die compatibel zijn met LLM, met een succesratio van 80%. De ontwikkeling beweegt zich van tool use richting het creëren van tools, en vervolgens naar het beheren van toolbibliotheken.

De derde optie is de dubbele protocollolaag van A2A + MCP. Het Agent2Agent Protocol van Google (A2A) lost problemen op die MCP niet kan aanpakken: communicatie tussen agent en agent. MCP zorgt voor de integratie van agent met tools; A2A regelt het ontdekken, onderhandelen en toewijzen van taken tussen agent en agent. De gecombineerde formule luidt: bouw met je framework, uitrust met MCP, en communiceer via A2A.

Belangrijkste conclusies

1. Kies de interface op basis van de actie: JSON voor kleine, typegebonden operaties, MCP voor gedeelde diensten, Skills voor procedures, CLI voor gevestigde commando’s, en sandboxed code voor lokale composities.
2. Houd de benchmark-condities verbonden aan het resultaat. CodeAct, Anthropic, Vercel, Cloudflare, Apideck en Scalekit hebben verschillende models-objecten, taken, hulpmiddelen en platforms gemeten.
3. De kwaliteit van ACI blijft behouden ondanks protocolwijzigingen. Duidelijke acties, compacte feedback, validatie en nuttige foutmeldingen ondersteunen alle modaliteiten.
4. Consolideer alleen overlappende hulpmiddelen wanneer evaluaties aantonen dat een vereenvoudigde benadering de selectie of het succes van de taak verbetert.
5. Beveiliging gaat hand in hand met uitvoeringsmacht. Shell- en codeinterfaces vereisen sandboxing; MCP heeft behoefte aan gefaseerde identiteitsbeheer en serverbeleid; Skills blijven instructies in plaats van controlemechanismen.

De volgende laag is de policy

Deel 4, AI Agent Beveiliging in 2026, Er wordt een beleidscontrole geplaatst tussen het voorgestelde tool call en de uitvoering. In Deel 5 wordt het hulpmiddel samen met zijn sandbox opgenomen binnen een herstelbare runtime. Deel 6 keert terug naar het interface vanuit het perspectief van harness: waarbij traces, evaluators, herhalingsregels en acceptatiecontroles het feedback van het hulpmiddel omzetten in een gestructureerd verbeteringsproces.

Referenties

Artikelen

• Uitvoerbare Code Actions leveren betere LLM Agents (CodeAct) op. — Wang et al., ICML 2024 — Acties gebaseerd op code leveren een 20% hoger succespercentage bij het uitvoeren van taken op dan JSON SWE-agent: Agent – Computerinterfaces maken geautomatiseerde softwareontwikkeling mogelijk — Yang, Jimenez et al., NeurIPS 2024 — Ontwerpprincipes voor ACI en evaluatie met SWE-bench (18,0% versus 7,3%, een verschil van 10,7 pp door het ontwerp van de interface)
• RAG-MCP: Het verminderen van Prompt opblazing bij de selectie van LLM hulpmiddelen — Hulpmiddel RAG dat de nauwkeurigheid van de selectie verhoogt van 13,62% naar 43,13% LLMs Als toolontwikkelaars (LATM) — Cai et al., 2023 — Tweefasenparadigma voor de creatie van agent-tools ToolMaker: LLM Agents Het maken van Agent tools — Wolflein et al., ACL 2025 — 80% succesratio bij het omzetten van repositories in tools
• MCPTox: Een uitgebreide MCP toxiciteitsanalyse Benchmark — 72,8% succesratio van aanvallen op 20 LLM agents en 45 MCP servers

Engineering bij Anthropic

• Geavanceerde Tool Use / Programmatische aanroep van tools — Hulzochting (85% schema-reductie), PTC en voorbeelden van tool use Codeuitvoering met MCP — 98,7% token vermindering (van 150K naar 2K tokens) dankzij een op code gebaseerd hulpprogramma orchestration
• Het ontwikkelen van effectieve hulpmiddelen voor Agents — Ingenieurswerk aan de beschrijving van de tool; invoervoorbeelden verbeteren de nauwkeurigheid; response_format enum (72 versus 206 tokens) Het ontwikkelen van effectieve Agents — ACI als fundamenteel ontwerpprincipe

Industriële casestudy’s

• Vercel: We hebben 80% van de tools voor onze Agent’s verwijderd — Van 15 naar 2 hulpmiddelen, succesratio van 80% tot 100%, 3,5 keer sneller, 40% minder tokens Cloudflare: Code-modus — TypeScript-gestuurde API aanroepen die tool schemas vervangen
• Apideck: MCP Een server die uw Context Window opslorpt — 550-1.400 tokens/tool, 55K tokens voor ongeveer 40 MCP tools, 143K/200K context verbruikt Scalekit: MCP versus CLI Token Benchmark — 4-32x token overhead voor MCP vergeleken met de CLI bij 75 benchmark uitvoeringen

Beveiliging

• Een kwetsbaar MCP project — 50 gemonitorde kwetsbaarheden, waarvan 13 kritiek, van 32 onderzoekers AuthZed: Tijdslijn van MCP-inbraken — 9 grote MCP beveiligingsincidenten (april-oktober 2025)
• Invariant Labs: MCP Aanvallen op vergiftiging van tools — Toolvergiftiging, rugblessures en cross-origin escalatie Pivot Point Security: MCP-analyse van beveiligingsrisico’s — 43% command injection, 43% fouten in de OAuth-authenticatie

CLI-ontwerp

• Het schrijven van CLI-tools die AI Agents daadwerkelijk gebruikt willen worden — Ugo Enyioha — Acht ontwerprichtlijnen voor CLIs die agent-vriendelijk zijn

Demo-project

• Marktanalist Agent — Volledige implementatie met consolidatie van tools en ACI-patronen

De volledige code van de Market Analyst Agent, inclusief de in dit artikel beschreven hulpprogrammaontwerpen, is beschikbaar op GitHub._

Reeks: Het ontwerpen van de Agentic-stack

• Deel 1: AI Agent Reasoning Lussen in 2026 — ReAct, ReWOO en Plan-en-Execute Deel 2: AI Agent Memory Architectuur in 2026 — checkpoints, vector stores en documentatiegeheugen
• Deel 3: AI Agent Tool Use in 2026 (dit artikel)
• Deel 4: AI Agent Beveiliging in 2026 — guardrails, rechten, sandboxes, HITL, en MCP scopebepaling
• Deel 5: Langdurig draaiende AI Agent Runtime in 2026 — sessions, sandboxes, checkpoints, harnassen en deployment vormen
• Deel 6: Harness Engineering voor AI Agents (komt eraan) — acceptatiecontroles, traces, herproberingen, overdrachten en de lus rondom de model