{
  "slug": "tool-use",
  "category": "concept",
  "updated": "2026-06-21",
  "version": "1.0",
  "url": "https://santismm.com/en/knowledge/tool-use",
  "urls": {
    "en": "https://santismm.com/en/knowledge/tool-use",
    "es": "https://santismm.com/es/knowledge/tool-use",
    "pt": "https://santismm.com/pt/knowledge/tool-use"
  },
  "evidence": {
    "evidenceLevel": "industry_observation",
    "confidenceLevel": "high",
    "sourceType": [
      "industry_observation",
      "paper"
    ]
  },
  "references": [
    {
      "title": "Schick et al. — Toolformer: Language Models Can Teach Themselves to Use Tools (2023)",
      "url": "https://arxiv.org/abs/2302.04761"
    },
    {
      "title": "Anthropic — Tool use (function calling)",
      "url": "https://docs.anthropic.com/en/docs/build-with-claude/tool-use"
    }
  ],
  "related": [
    "ai-agent",
    "model-context-protocol",
    "agentic-ai",
    "harness-engineering"
  ],
  "locales": {
    "en": {
      "title": "What is Tool Use (Function Calling)?",
      "summary": "Tool use, also called function calling, lets a language model invoke external functions, APIs or code to fetch information or take actions in the real world. The model decides which tool to call and with what arguments; the application runs the tool and returns the result, which the model uses to continue. Tool use is the bridge that turns a text generator into an agent that can actually do things.",
      "definition": "Tool use (function calling) is the capability that lets a language model call predefined external functions or APIs, with arguments it generates, and incorporate the results into its response or next step.",
      "takeaways": [
        "Tool use connects a model to live data and real actions.",
        "The model picks the tool and arguments; the app executes it.",
        "Clear, well-described tools dramatically improve reliability.",
        "It is the core mechanism behind agents and MCP.",
        "Tool access expands capability and the security surface alike."
      ],
      "context": [
        "On its own a model only produces text. Tool use breaks that boundary: given a set of declared tools, the model can choose to call one — for example a search, a database query or a payment API — and then reason over the result.",
        "How tools are described matters as much as the model. Tools written for a model to use — clear names, precise parameters, helpful descriptions and error messages — are a central concern of harness engineering."
      ],
      "architecture": [
        "The loop: the application declares tools (name, description, parameter schema); the model emits a structured tool call; the application validates and executes it; the result returns to the model as an observation; the model continues or answers.",
        "MCP standardizes how tools are exposed and discovered across applications, so a tool written once can be reused by any compliant client. Guardrails and permissions wrap execution to keep it safe."
      ],
      "components": [
        "Tool declaration (schema)",
        "Tool selection (model)",
        "Argument generation",
        "Execution layer",
        "Result / observation",
        "Guardrails & permissions"
      ],
      "pros": [
        "Grounds answers in live, real data.",
        "Lets models take real actions, not just describe them.",
        "Extends a model without retraining.",
        "Composes into full agentic workflows."
      ],
      "risks": [
        "Prompt injection can trigger unintended tool calls.",
        "Wrong arguments or tool misuse cause real-world errors.",
        "Over-broad tool access widens the attack surface.",
        "Latency and cost grow with each tool round-trip."
      ],
      "tools": [
        "Function calling APIs",
        "Model Context Protocol (MCP)",
        "LangGraph / Agents SDKs",
        "Schema validation (e.g. JSON Schema, Zod)"
      ],
      "examples": [
        "A model calling a weather API to answer a forecast question.",
        "An agent querying a database to look up an order before acting.",
        "A coding agent invoking a test runner and reading the results."
      ],
      "faqs": [
        {
          "q": "Is tool use the same as MCP?",
          "a": "No. Tool use is the model capability to call functions. MCP is a standard for how those tools and data are exposed and discovered across applications."
        },
        {
          "q": "How do you make tool use reliable?",
          "a": "Write tools for the model: clear names, precise parameter schemas, useful descriptions and informative errors. Validate arguments and constrain permissions."
        },
        {
          "q": "What are the security risks?",
          "a": "Tools are real access. Prompt injection can attempt to trigger harmful calls, so apply least-privilege permissions, validate inputs, and treat tool outputs as untrusted."
        },
        {
          "q": "Does tool use make a model an agent?",
          "a": "It is the key enabler. An agent combines tool use with a control loop, memory and a goal so it can act over multiple steps."
        }
      ]
    },
    "es": {
      "title": "¿Qué es el Uso de Herramientas (Function Calling)?",
      "summary": "El uso de herramientas, también llamado function calling, permite a un modelo de lenguaje invocar funciones, APIs o código externos para obtener información o tomar acciones en el mundo real. El modelo decide qué herramienta llamar y con qué argumentos; la aplicación ejecuta la herramienta y devuelve el resultado, que el modelo usa para continuar. El uso de herramientas es el puente que convierte a un generador de texto en un agente que de verdad hace cosas.",
      "definition": "El uso de herramientas (function calling) es la capacidad que permite a un modelo de lenguaje llamar a funciones o APIs externas predefinidas, con argumentos que genera, e incorporar los resultados a su respuesta o siguiente paso.",
      "takeaways": [
        "El uso de herramientas conecta un modelo con datos en vivo y acciones reales.",
        "El modelo elige la herramienta y los argumentos; la aplicación la ejecuta.",
        "Herramientas claras y bien descritas mejoran mucho la fiabilidad.",
        "Es el mecanismo central detrás de los agentes y de MCP.",
        "El acceso a herramientas amplía la capacidad y la superficie de seguridad por igual."
      ],
      "context": [
        "Por sí solo un modelo solo produce texto. El uso de herramientas rompe esa frontera: dado un conjunto de herramientas declaradas, el modelo puede elegir llamar a una —por ejemplo una búsqueda, una consulta a base de datos o una API de pago— y luego razonar sobre el resultado.",
        "Cómo se describen las herramientas importa tanto como el modelo. Las herramientas escritas para que las use un modelo —nombres claros, parámetros precisos, descripciones útiles y mensajes de error— son una preocupación central de la ingeniería de harness."
      ],
      "architecture": [
        "El bucle: la aplicación declara herramientas (nombre, descripción, esquema de parámetros); el modelo emite una llamada estructurada; la aplicación la valida y ejecuta; el resultado vuelve al modelo como observación; el modelo continúa o responde.",
        "MCP estandariza cómo se exponen y descubren las herramientas entre aplicaciones, de modo que una herramienta escrita una vez se reutiliza en cualquier cliente compatible. Los guardarraíles y permisos envuelven la ejecución para mantenerla segura."
      ],
      "components": [
        "Declaración de herramienta (esquema)",
        "Selección de herramienta (modelo)",
        "Generación de argumentos",
        "Capa de ejecución",
        "Resultado / observación",
        "Guardarraíles y permisos"
      ],
      "pros": [
        "Fundamenta las respuestas en datos reales y en vivo.",
        "Permite a los modelos tomar acciones reales, no solo describirlas.",
        "Extiende un modelo sin reentrenarlo.",
        "Se compone en flujos agénticos completos."
      ],
      "risks": [
        "La inyección de prompts puede disparar llamadas no deseadas.",
        "Argumentos erróneos o mal uso de herramientas causan errores reales.",
        "Un acceso demasiado amplio a herramientas amplía la superficie de ataque.",
        "La latencia y el coste crecen con cada ida y vuelta a una herramienta."
      ],
      "tools": [
        "APIs de function calling",
        "Model Context Protocol (MCP)",
        "LangGraph / SDKs de agentes",
        "Validación de esquemas (p. ej. JSON Schema, Zod)"
      ],
      "examples": [
        "Un modelo que llama a una API del tiempo para responder sobre el pronóstico.",
        "Un agente que consulta una base de datos para buscar un pedido antes de actuar.",
        "Un agente de programación que invoca un runner de tests y lee los resultados."
      ],
      "faqs": [
        {
          "q": "¿El uso de herramientas es lo mismo que MCP?",
          "a": "No. El uso de herramientas es la capacidad del modelo de llamar a funciones. MCP es un estándar de cómo se exponen y descubren esas herramientas y datos entre aplicaciones."
        },
        {
          "q": "¿Cómo se hace fiable el uso de herramientas?",
          "a": "Escribiendo las herramientas para el modelo: nombres claros, esquemas de parámetros precisos, descripciones útiles y errores informativos. Validar argumentos y limitar permisos."
        },
        {
          "q": "¿Cuáles son los riesgos de seguridad?",
          "a": "Las herramientas son acceso real. La inyección de prompts puede intentar disparar llamadas dañinas, así que aplica permisos de mínimo privilegio, valida entradas y trata las salidas como no confiables."
        },
        {
          "q": "¿El uso de herramientas convierte a un modelo en agente?",
          "a": "Es el habilitador clave. Un agente combina el uso de herramientas con un bucle de control, memoria y un objetivo para actuar en varios pasos."
        }
      ]
    },
    "pt": {
      "title": "O que é Uso de Ferramentas (Function Calling)?",
      "summary": "O uso de ferramentas, também chamado function calling, permite a um modelo de linguagem invocar funções, APIs ou código externos para obter informação ou tomar ações no mundo real. O modelo decide qual ferramenta chamar e com quais argumentos; a aplicação executa a ferramenta e devolve o resultado, que o modelo usa para continuar. O uso de ferramentas é a ponte que transforma um gerador de texto num agente que de fato faz coisas.",
      "definition": "O uso de ferramentas (function calling) é a capacidade que permite a um modelo de linguagem chamar funções ou APIs externas predefinidas, com argumentos que gera, e incorporar os resultados à sua resposta ou próximo passo.",
      "takeaways": [
        "O uso de ferramentas conecta um modelo a dados ao vivo e ações reais.",
        "O modelo escolhe a ferramenta e os argumentos; a aplicação a executa.",
        "Ferramentas claras e bem descritas melhoram muito a confiabilidade.",
        "É o mecanismo central por trás dos agentes e do MCP.",
        "O acesso a ferramentas amplia a capacidade e a superfície de segurança igualmente."
      ],
      "context": [
        "Sozinho, um modelo só produz texto. O uso de ferramentas quebra essa fronteira: dado um conjunto de ferramentas declaradas, o modelo pode escolher chamar uma — por exemplo uma busca, uma consulta a banco de dados ou uma API de pagamento — e então raciocinar sobre o resultado.",
        "Como as ferramentas são descritas importa tanto quanto o modelo. Ferramentas escritas para um modelo usar — nomes claros, parâmetros precisos, descrições úteis e mensagens de erro — são uma preocupação central da engenharia de harness."
      ],
      "architecture": [
        "O laço: a aplicação declara ferramentas (nome, descrição, esquema de parâmetros); o modelo emite uma chamada estruturada; a aplicação a valida e executa; o resultado retorna ao modelo como observação; o modelo continua ou responde.",
        "O MCP padroniza como as ferramentas são expostas e descobertas entre aplicações, de modo que uma ferramenta escrita uma vez é reutilizada por qualquer cliente compatível. Guard-rails e permissões envolvem a execução para mantê-la segura."
      ],
      "components": [
        "Declaração de ferramenta (esquema)",
        "Seleção de ferramenta (modelo)",
        "Geração de argumentos",
        "Camada de execução",
        "Resultado / observação",
        "Guard-rails e permissões"
      ],
      "pros": [
        "Fundamenta as respostas em dados reais e ao vivo.",
        "Permite aos modelos tomar ações reais, não só descrevê-las.",
        "Estende um modelo sem retreiná-lo.",
        "Compõe-se em fluxos agênticos completos."
      ],
      "risks": [
        "A injeção de prompts pode disparar chamadas indesejadas.",
        "Argumentos errados ou mau uso de ferramentas causam erros reais.",
        "Um acesso amplo demais a ferramentas amplia a superfície de ataque.",
        "A latência e o custo crescem a cada ida e volta a uma ferramenta."
      ],
      "tools": [
        "APIs de function calling",
        "Model Context Protocol (MCP)",
        "LangGraph / SDKs de agentes",
        "Validação de esquemas (ex.: JSON Schema, Zod)"
      ],
      "examples": [
        "Um modelo que chama uma API de clima para responder sobre a previsão.",
        "Um agente que consulta um banco de dados para buscar um pedido antes de agir.",
        "Um agente de programação que invoca um runner de testes e lê os resultados."
      ],
      "faqs": [
        {
          "q": "O uso de ferramentas é o mesmo que MCP?",
          "a": "Não. O uso de ferramentas é a capacidade do modelo de chamar funções. O MCP é um padrão de como essas ferramentas e dados são expostos e descobertos entre aplicações."
        },
        {
          "q": "Como tornar o uso de ferramentas confiável?",
          "a": "Escrevendo as ferramentas para o modelo: nomes claros, esquemas de parâmetros precisos, descrições úteis e erros informativos. Validar argumentos e limitar permissões."
        },
        {
          "q": "Quais são os riscos de segurança?",
          "a": "Ferramentas são acesso real. A injeção de prompts pode tentar disparar chamadas nocivas, então aplique permissões de privilégio mínimo, valide entradas e trate as saídas como não confiáveis."
        },
        {
          "q": "O uso de ferramentas torna um modelo um agente?",
          "a": "É o habilitador-chave. Um agente combina o uso de ferramentas com um laço de controle, memória e um objetivo para agir em vários passos."
        }
      ]
    }
  }
}