santismm-knowledge-mcp 0.2.1

package/content/knowledge/reasoning-models.json

@@ -0,0 +1,153 @@
+{
+  "slug": "reasoning-models",
+  "category": "concept",
+  "updated": "2026-06-21",
+  "version": "1.0",
+  "related": ["foundation-models", "agentic-ai", "prompt-engineering", "agentic-evaluation"],
+  "references": [
+    { "title": "Wei et al. — Chain-of-Thought Prompting Elicits Reasoning in LLMs (2022)", "url": "https://arxiv.org/abs/2201.11903" },
+    { "title": "DeepSeek-AI — DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via RL (2025)", "url": "https://arxiv.org/abs/2501.12948" }
+  ],
+  "evidence": {
+    "evidenceLevel": "benchmark",
+    "confidenceLevel": "high",
+    "sourceType": ["benchmark", "paper"]
+  },
+  "locales": {
+    "en": {
+      "title": "What are Reasoning Models?",
+      "summary": "Reasoning models are language models trained to spend extra computation 'thinking' before they answer — generating internal reasoning steps to solve harder problems in math, code and logic. They trade latency and cost for accuracy on complex, multi-step tasks. The key idea is test-time compute: letting a model reason longer at inference, rather than only making the model bigger, can substantially improve results.",
+      "definition": "Reasoning models are language models optimized to perform extended step-by-step reasoning at inference time — using additional test-time compute — to improve accuracy on complex, multi-step problems.",
+      "takeaways": [
+        "They 'think' before answering, using extra inference compute.",
+        "Test-time compute is a new scaling axis beyond model size.",
+        "Best for math, code, logic and multi-step planning.",
+        "They trade latency and token cost for accuracy.",
+        "Overkill for simple tasks — match the model to the problem."
+      ],
+      "context": [
+        "Standard models answer in roughly constant time regardless of difficulty. Reasoning models break that: they generate a chain of internal reasoning, effectively spending more compute on harder questions, which lifts performance on tasks that need multi-step deduction.",
+        "This introduced a second scaling axis. Beyond making models larger (train-time compute), you can let them reason longer at inference (test-time compute) — a major driver of recent progress on hard benchmarks."
+      ],
+      "architecture": [
+        "Reasoning models are typically trained to produce long internal reasoning before a final answer, often reinforced with reinforcement learning that rewards correct outcomes. At inference, more 'thinking' tokens generally mean better answers on hard problems.",
+        "In agentic systems, reasoning models serve as strong planners and decision-makers, while cheaper, faster models can handle routine steps. Routing between them by task difficulty is a common cost-control pattern."
+      ],
+      "components": ["Extended reasoning (thinking tokens)", "Test-time compute budget", "RL-based training for reasoning", "Final-answer extraction"],
+      "pros": [
+        "Higher accuracy on complex, multi-step problems.",
+        "Strong at math, coding and planning.",
+        "Reasoning effort can be scaled per query.",
+        "Good planners at the core of capable agents."
+      ],
+      "risks": [
+        "Higher latency and token cost.",
+        "Overkill — and wasteful — for simple tasks.",
+        "Longer reasoning is not always more correct.",
+        "Internal reasoning can be hard to audit or trust verbatim."
+      ],
+      "tools": ["Reasoning model tiers from major providers", "Adjustable reasoning-effort settings", "Model routing by task difficulty", "Evaluation suites"],
+      "examples": [
+        "Solving a multi-step math or logic problem that trips up a standard model.",
+        "Planning a complex agent task before execution.",
+        "Routing only hard tickets to a reasoning model to control cost."
+      ],
+      "faqs": [
+        { "q": "How are reasoning models different from standard LLMs?", "a": "They are trained and configured to reason at length before answering, spending more inference compute on hard problems instead of replying in near-constant time." },
+        { "q": "What is test-time compute?", "a": "Computation spent at inference (the model 'thinking' longer), as opposed to train-time compute spent making the model. It is a distinct way to improve results." },
+        { "q": "Should I always use a reasoning model?", "a": "No. They cost more and add latency. Use them for hard, multi-step problems and route simpler tasks to faster, cheaper models." },
+        { "q": "Do they eliminate hallucination?", "a": "No. Reasoning improves accuracy on many tasks but does not guarantee correctness; grounding, tools and evaluation remain necessary." }
+      ]
+    },
+    "es": {
+      "title": "¿Qué son los Modelos de Razonamiento (Reasoning Models)?",
+      "summary": "Los modelos de razonamiento son modelos de lenguaje entrenados para gastar cómputo extra 'pensando' antes de responder, generando pasos de razonamiento internos para resolver problemas más difíciles de matemáticas, código y lógica. Cambian latencia y coste por precisión en tareas complejas de varios pasos. La idea clave es el cómputo en inferencia (test-time compute): dejar que un modelo razone más en la inferencia, en vez de solo hacerlo más grande, puede mejorar mucho los resultados.",
+      "definition": "Los modelos de razonamiento son modelos de lenguaje optimizados para realizar razonamiento extendido paso a paso en el momento de la inferencia —usando cómputo adicional en inferencia— para mejorar la precisión en problemas complejos de varios pasos.",
+      "takeaways": [
+        "'Piensan' antes de responder, usando cómputo extra en inferencia.",
+        "El cómputo en inferencia es un nuevo eje de escalado más allá del tamaño.",
+        "Mejores para matemáticas, código, lógica y planificación de varios pasos.",
+        "Cambian latencia y coste de tokens por precisión.",
+        "Excesivos para tareas simples: ajusta el modelo al problema."
+      ],
+      "context": [
+        "Los modelos estándar responden en un tiempo casi constante sin importar la dificultad. Los modelos de razonamiento rompen eso: generan una cadena de razonamiento interno, gastando de hecho más cómputo en preguntas más difíciles, lo que mejora tareas que necesitan deducción de varios pasos.",
+        "Esto introdujo un segundo eje de escalado. Más allá de hacer modelos más grandes (cómputo en entrenamiento), puedes dejarlos razonar más en inferencia (cómputo en inferencia): un motor importante del progreso reciente en benchmarks difíciles."
+      ],
+      "architecture": [
+        "Los modelos de razonamiento suelen entrenarse para producir un razonamiento interno largo antes de la respuesta final, a menudo reforzado con aprendizaje por refuerzo que premia resultados correctos. En inferencia, más tokens de 'pensamiento' suelen significar mejores respuestas en problemas difíciles.",
+        "En sistemas agénticos, los modelos de razonamiento sirven como planificadores y decisores fuertes, mientras que modelos más baratos y rápidos manejan pasos rutinarios. Enrutar entre ellos según la dificultad es un patrón común de control de coste."
+      ],
+      "components": ["Razonamiento extendido (tokens de pensamiento)", "Presupuesto de cómputo en inferencia", "Entrenamiento por RL para razonar", "Extracción de la respuesta final"],
+      "pros": [
+        "Mayor precisión en problemas complejos de varios pasos.",
+        "Fuertes en matemáticas, programación y planificación.",
+        "El esfuerzo de razonamiento puede escalarse por consulta.",
+        "Buenos planificadores en el núcleo de agentes capaces."
+      ],
+      "risks": [
+        "Mayor latencia y coste de tokens.",
+        "Excesivos —y derrochadores— para tareas simples.",
+        "Razonar más no siempre es más correcto.",
+        "El razonamiento interno puede ser difícil de auditar o de creer al pie de la letra."
+      ],
+      "tools": ["Niveles de modelos de razonamiento de los grandes proveedores", "Ajustes de esfuerzo de razonamiento", "Enrutamiento de modelos por dificultad", "Suites de evaluación"],
+      "examples": [
+        "Resolver un problema de matemáticas o lógica de varios pasos que confunde a un modelo estándar.",
+        "Planificar una tarea de agente compleja antes de ejecutarla.",
+        "Enrutar solo los tickets difíciles a un modelo de razonamiento para controlar el coste."
+      ],
+      "faqs": [
+        { "q": "¿En qué se diferencian de los LLM estándar?", "a": "Están entrenados y configurados para razonar extensamente antes de responder, gastando más cómputo en inferencia en problemas difíciles en vez de responder en tiempo casi constante." },
+        { "q": "¿Qué es el cómputo en inferencia?", "a": "El cómputo gastado en la inferencia (el modelo 'pensando' más tiempo), frente al cómputo en entrenamiento gastado en construir el modelo. Es una forma distinta de mejorar resultados." },
+        { "q": "¿Debería usar siempre un modelo de razonamiento?", "a": "No. Cuestan más y añaden latencia. Úsalos para problemas difíciles de varios pasos y enruta las tareas simples a modelos más rápidos y baratos." },
+        { "q": "¿Eliminan la alucinación?", "a": "No. El razonamiento mejora la precisión en muchas tareas pero no garantiza la corrección; siguen siendo necesarios la fundamentación, las herramientas y la evaluación." }
+      ]
+    },
+    "pt": {
+      "title": "O que são Modelos de Raciocínio (Reasoning Models)?",
+      "summary": "Os modelos de raciocínio são modelos de linguagem treinados para gastar computação extra 'pensando' antes de responder, gerando passos de raciocínio internos para resolver problemas mais difíceis de matemática, código e lógica. Trocam latência e custo por precisão em tarefas complexas de vários passos. A ideia central é a computação em inferência (test-time compute): deixar um modelo raciocinar mais na inferência, em vez de só torná-lo maior, pode melhorar muito os resultados.",
+      "definition": "Os modelos de raciocínio são modelos de linguagem otimizados para realizar raciocínio estendido passo a passo no momento da inferência — usando computação adicional em inferência — para melhorar a precisão em problemas complexos de vários passos.",
+      "takeaways": [
+        "'Pensam' antes de responder, usando computação extra em inferência.",
+        "A computação em inferência é um novo eixo de escala além do tamanho.",
+        "Melhores para matemática, código, lógica e planejamento de vários passos.",
+        "Trocam latência e custo de tokens por precisão.",
+        "Exagero para tarefas simples: ajuste o modelo ao problema."
+      ],
+      "context": [
+        "Os modelos padrão respondem em tempo quase constante independentemente da dificuldade. Os modelos de raciocínio quebram isso: geram uma cadeia de raciocínio interno, gastando de fato mais computação em perguntas mais difíceis, o que melhora tarefas que precisam de dedução de vários passos.",
+        "Isso introduziu um segundo eixo de escala. Além de tornar os modelos maiores (computação em treinamento), você pode deixá-los raciocinar mais na inferência (computação em inferência): um motor importante do progresso recente em benchmarks difíceis."
+      ],
+      "architecture": [
+        "Os modelos de raciocínio costumam ser treinados para produzir um raciocínio interno longo antes da resposta final, muitas vezes reforçado com aprendizado por reforço que premia resultados corretos. Na inferência, mais tokens de 'pensamento' costumam significar melhores respostas em problemas difíceis.",
+        "Em sistemas agênticos, os modelos de raciocínio servem como planejadores e decisores fortes, enquanto modelos mais baratos e rápidos lidam com passos rotineiros. Rotear entre eles conforme a dificuldade é um padrão comum de controle de custo."
+      ],
+      "components": ["Raciocínio estendido (tokens de pensamento)", "Orçamento de computação em inferência", "Treinamento por RL para raciocinar", "Extração da resposta final"],
+      "pros": [
+        "Maior precisão em problemas complexos de vários passos.",
+        "Fortes em matemática, programação e planejamento.",
+        "O esforço de raciocínio pode ser escalado por consulta.",
+        "Bons planejadores no núcleo de agentes capazes."
+      ],
+      "risks": [
+        "Maior latência e custo de tokens.",
+        "Exagero — e desperdício — para tarefas simples.",
+        "Raciocinar mais nem sempre é mais correto.",
+        "O raciocínio interno pode ser difícil de auditar ou de crer ao pé da letra."
+      ],
+      "tools": ["Níveis de modelos de raciocínio dos grandes provedores", "Ajustes de esforço de raciocínio", "Roteamento de modelos por dificuldade", "Suítes de avaliação"],
+      "examples": [
+        "Resolver um problema de matemática ou lógica de vários passos que confunde um modelo padrão.",
+        "Planejar uma tarefa de agente complexa antes de executá-la.",
+        "Rotear só os chamados difíceis a um modelo de raciocínio para controlar o custo."
+      ],
+      "faqs": [
+        { "q": "Como diferem dos LLMs padrão?", "a": "São treinados e configurados para raciocinar longamente antes de responder, gastando mais computação em inferência em problemas difíceis em vez de responder em tempo quase constante." },
+        { "q": "O que é computação em inferência?", "a": "A computação gasta na inferência (o modelo 'pensando' mais tempo), frente à computação em treinamento gasta em construir o modelo. É uma forma distinta de melhorar resultados." },
+        { "q": "Devo usar sempre um modelo de raciocínio?", "a": "Não. Custam mais e adicionam latência. Use-os para problemas difíceis de vários passos e roteie as tarefas simples a modelos mais rápidos e baratos." },
+        { "q": "Eles eliminam a alucinação?", "a": "Não. O raciocínio melhora a precisão em muitas tarefas mas não garante a correção; fundamentação, ferramentas e avaliação seguem necessárias." }
+      ]
+    }
+  }
+}

package/content/knowledge/tool-use.json

@@ -0,0 +1,156 @@
+{
+  "slug": "tool-use",
+  "category": "concept",
+  "updated": "2026-06-24",
+  "version": "1.1",
+  "related": ["ai-agent", "model-context-protocol", "agentic-ai", "harness-engineering"],
+  "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" }
+  ],
+  "evidence": {
+    "evidenceLevel": "production",
+    "confidenceLevel": "medium",
+    "sourceType": ["production_system", "personal_experience", "industry_observation", "paper"]
+  },
+  "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.",
+        "In practice: an autonomous OpenClaw agent issued 800 tool calls across 10 distinct tools over 57 days — exec (481), web_search (190), write (48), web_fetch (22), read (21) and others — averaging 5.97 tool calls per session. A single-operator local-first deployment, measured from the agent's own traces."
+      ],
+      "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.",
+        "En la práctica: un agente autónomo OpenClaw realizó 800 llamadas a herramientas entre 10 herramientas distintas en 57 días — exec (481), web_search (190), write (48), web_fetch (22), read (21) y otras — con una media de 5,97 llamadas por sesión. Despliegue local-first mono-operador, medido desde las propias trazas del agente."
+      ],
+      "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.",
+        "Na prática: um agente autônomo OpenClaw fez 800 chamadas de ferramentas entre 10 ferramentas distintas em 57 dias — exec (481), web_search (190), write (48), web_fetch (22), read (21) e outras — com média de 5,97 chamadas por sessão. Implantação local-first de operador único, medida a partir dos próprios rastros do agente."
+      ],
+      "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." }
+      ]
+    }
+  }
+}

package/content/library/cognitive-architecture-emergent-ai.md

@@ -0,0 +1,15 @@
+---
+title: "Cognitive Architecture and Emergent Phenomena in Advanced AI"
+titles: { es: "La arquitectura cognitiva y los fenómenos emergentes de la IA avanzada" }
+date: "2025-06-07"
+kind: "article"
+summary: "A synthesis of current mechanistic and behavioral research on how cognitive structures and emergent behavior arise in modern AI systems."
+topics: ["Cognitive Architecture", "Foundation Models", "Research"]
+featured: true
+host: "EUREKA · Substack"
+canonicalUrl: "https://santismm.substack.com/p/cognitive-architecture-and-emergent"
+links:
+  - { platform: "substack", lang: "en", url: "https://santismm.substack.com/p/cognitive-architecture-and-emergent" }
+  - { platform: "medium", lang: "en", url: "https://medium.com/@santismm/cognitive-architecture-and-emergent-phenomena-in-advanced-ai-d48ce7b825a1" }
+  - { platform: "medium", lang: "es", url: "https://medium.com/@santismm/la-arquitectura-cognitiva-y-los-fen%C3%B3menos-emergentes-de-la-ia-avanzada-c949bb787f83" }
+---

package/content/library/devready-ep108-ai-customer-experiences.md

@@ -0,0 +1,14 @@
+---
+title: "Innovating Customer Experiences & Empowering Brands Through AI"
+date: "2024-04-01"
+kind: "podcast"
+summary: "DevReady Podcast (Ep. 108). A deep conversation on how conversational and generative AI are reshaping customer experience and the way brands operate."
+topics: ["Conversational AI", "Generative AI", "Customer Experience"]
+featured: true
+host: "DevReady Podcast · Aerion Technologies"
+thumbnail: "https://i.ytimg.com/vi/eC66YJDR8yA/hqdefault.jpg"
+canonicalUrl: "https://www.youtube.com/watch?v=eC66YJDR8yA"
+links:
+  - { platform: "youtube", lang: "en", url: "https://www.youtube.com/watch?v=eC66YJDR8yA" }
+  - { platform: "spotify", lang: "en", url: "https://open.spotify.com/show/4ESPCD6LXZGHsbYbV9KSQ7", label: "Listen on Spotify" }
+---

package/content/library/how-genai-impact-business.md

@@ -0,0 +1,12 @@
+---
+title: "How GenAI Impacts Business?"
+date: "2023-12-21"
+kind: "article"
+summary: "A step-by-step guide to surf the innovation storm without sinking — how generative AI actually lands inside a business."
+topics: ["Generative AI", "Business Strategy"]
+featured: false
+host: "Medium"
+canonicalUrl: "https://medium.com/@santismm/how-genai-impact-business-157238231948"
+links:
+  - { platform: "medium", lang: "en", url: "https://medium.com/@santismm/how-genai-impact-business-157238231948" }
+---

package/content/library/lmm-reshaping-industries-2024.md

@@ -0,0 +1,12 @@
+---
+title: "The Era of Generative AI: How Large Multimodal Models are Reshaping Industries in 2024"
+date: "2024-01-11"
+kind: "article"
+summary: "Why 2024 became the year of the Large Multimodal Model (LMM), and what that means across industries."
+topics: ["Generative AI", "Foundation Models"]
+featured: false
+host: "Medium"
+canonicalUrl: "https://medium.com/@santismm/the-era-of-generative-ai-how-large-multimodal-models-are-reshaping-industries-in-2024-fe62ae1678ab"
+links:
+  - { platform: "medium", lang: "en", url: "https://medium.com/@santismm/the-era-of-generative-ai-how-large-multimodal-models-are-reshaping-industries-in-2024-fe62ae1678ab" }
+---

package/content/library/rethinking-ai-pause.md

@@ -0,0 +1,12 @@
+---
+title: "Rethinking the AI Pause: Potential Pitfalls and Unintended Consequences"
+date: "2023-04-06"
+kind: "article"
+summary: "A measured take on the 2023 'AI pause' debate — what a moratorium would actually mean for innovation, safety and competition."
+topics: ["AI Strategy", "Policy"]
+featured: false
+host: "LinkedIn"
+canonicalUrl: "https://www.linkedin.com/pulse/rethinking-ai-pause-potential-pitfalls-unintended-santiago"
+links:
+  - { platform: "linkedin", lang: "en", url: "https://www.linkedin.com/pulse/rethinking-ai-pause-potential-pitfalls-unintended-santiago" }
+---

package/content/library/rise-of-agentic-ai.md

@@ -0,0 +1,16 @@
+---
+title: "The Rise of Agentic AI"
+titles: { es: "El auge de la IA agéntica" }
+date: "2025-04-09"
+kind: "article"
+summary: "How agentic AI is revolutionizing business strategy — and the shift from do-it-yourself to do-it-for-me software."
+topics: ["Agentic AI", "Business Strategy"]
+featured: true
+host: "EUREKA · Substack"
+canonicalUrl: "https://santismm.substack.com/p/the-rise-of-agentic-ai"
+links:
+  - { platform: "substack", lang: "en", url: "https://santismm.substack.com/p/the-rise-of-agentic-ai" }
+  - { platform: "medium", lang: "en", url: "https://medium.com/@santismm/the-rise-of-agentic-ai-a85ba0a72709" }
+  - { platform: "medium", lang: "es", url: "https://medium.com/@santismm/a-diferencia-de-la-ia-tradicional-o-generativa-la-ia-ag%C3%A9ntica-agentic-ai-puede-tomar-decisiones-da8c9d5a3477" }
+  - { platform: "linkedin", lang: "en", url: "https://www.linkedin.com/pulse/from-do-yourself-me-why-agentic-ai-next-strategic-new-santiago-mysee" }
+---

package/content/library/self-improving-autonomous-ai.md

@@ -0,0 +1,16 @@
+---
+title: "The next generation of AI: Self-Improvement and Autonomous Learning"
+titles: { es: "La próxima generación de IA: modelos que se perfeccionan solos" }
+date: "2025-05-30"
+kind: "article"
+summary: "Self-improvement and autonomous learning in AI — and the road to an intelligence explosion."
+topics: ["Foundation Models", "Agentic AI", "Research"]
+featured: true
+host: "EUREKA · Substack"
+canonicalUrl: "https://santismm.substack.com/p/the-next-generation-of-ai-self-improvement"
+links:
+  - { platform: "substack", lang: "en", url: "https://santismm.substack.com/p/the-next-generation-of-ai-self-improvement" }
+  - { platform: "medium", lang: "en", url: "https://medium.com/@santismm/the-next-generation-of-ai-self-improvement-and-autonomous-learning-fef93d92e511" }
+  - { platform: "medium", lang: "es", url: "https://medium.com/@santismm/la-pr%C3%B3xima-generaci%C3%B3n-de-ia-modelos-que-se-perfeccionan-solos-1d91cf3db458" }
+  - { platform: "linkedin", lang: "en", url: "https://www.linkedin.com/pulse/beyond-human-input-how-self-improving-ai-rewriting-santiago-6ybte" }
+---

package/content/library/the-stopwatch-and-the-exam.md

@@ -0,0 +1,12 @@
+---
+title: "The Stopwatch and the Exam"
+date: "2026-06-15"
+kind: "article"
+summary: "Static benchmarks did not die. They stopped being enough. The move from measuring capability to measuring agency, the harness problem underneath it, and where attention belongs now. Backed by a public catalog of 69 agentic benchmarks."
+topics: ["AI Evaluation", "Agentic AI", "Benchmarks"]
+featured: true
+host: "articles.santismm.com"
+canonicalUrl: "https://articles.santismm.com/the-stopwatch-and-the-exam/"
+links:
+  - { platform: "site", lang: "en", url: "https://articles.santismm.com/the-stopwatch-and-the-exam/" }
+---

package/content/library/unlock-gpt4-secrets.md

@@ -0,0 +1,12 @@
+---
+title: "Unlock the Secret Language of Success: How GPT-4's Superpowers Are Changing the Game"
+date: "2023-03-30"
+kind: "article"
+summary: "An early look at GPT-4's qualitative leap and what its emergent capabilities meant for products and teams."
+topics: ["Generative AI", "Foundation Models"]
+featured: false
+host: "LinkedIn"
+canonicalUrl: "https://www.linkedin.com/pulse/unlock-secret-language-success-how-gpt-4s-superpowers-santiago"
+links:
+  - { platform: "linkedin", lang: "en", url: "https://www.linkedin.com/pulse/unlock-secret-language-success-how-gpt-4s-superpowers-santiago" }
+---

package/content/library/vibe-coding-enterprise.md

@@ -0,0 +1,15 @@
+---
+title: "Vibe Coding in Enterprise Software"
+titles: { es: "Vibe Coding en el software empresarial" }
+date: "2025-04-30"
+kind: "article"
+summary: "AI-assisted software development in 2025: state of the art, risks and best practices for shipping it in real organizations."
+topics: ["Vibe Coding", "Engineering", "Productivity"]
+featured: true
+host: "EUREKA · Substack"
+canonicalUrl: "https://santismm.substack.com/p/vibe-coding-in-enterprise-software"
+links:
+  - { platform: "substack", lang: "en", url: "https://santismm.substack.com/p/vibe-coding-in-enterprise-software" }
+  - { platform: "medium", lang: "en", url: "https://medium.com/@santismm/vibe-coding-in-enterprise-software-c2921546613a" }
+  - { platform: "medium", lang: "es", url: "https://medium.com/@santismm/vibe-coding-en-el-software-empresarial-fba73f2cba5f" }
+---

package/content/library/video-transformando-negocios-genai.md

@@ -0,0 +1,14 @@
+---
+title: "Transformando Negocios con IA Generativa"
+date: "2024-09-01"
+kind: "video"
+summary: "Conversación sobre cómo la IA Generativa transforma operaciones, productos y experiencia de cliente en la empresa."
+topics: ["Generative AI", "Conversational AI", "Business Strategy"]
+featured: true
+host: "NTT DATA LATAM · YouTube"
+duration: "video"
+thumbnail: "https://i.ytimg.com/vi/Z3UBPqsx6XI/hqdefault.jpg"
+canonicalUrl: "https://www.youtube.com/watch?v=Z3UBPqsx6XI"
+links:
+  - { platform: "youtube", lang: "es", url: "https://www.youtube.com/watch?v=Z3UBPqsx6XI" }
+---

package/content/library/video-volando-alto-sky-airlines.md

@@ -0,0 +1,13 @@
+---
+title: "Volando Alto con la Tecnología: una charla con Felipe Izquierdo, CTO de Sky Airlines"
+date: "2024-11-01"
+kind: "video"
+summary: "Charla con el CTO de Sky Airlines sobre transformación tecnológica, IA y experiencia de cliente en la aviación."
+topics: ["Conversational AI", "Business Strategy"]
+featured: false
+host: "NTT DATA LATAM · YouTube"
+thumbnail: "https://i.ytimg.com/vi/el8E6AsMeUI/hqdefault.jpg"
+canonicalUrl: "https://www.youtube.com/watch?v=el8E6AsMeUI"
+links:
+  - { platform: "youtube", lang: "es", url: "https://www.youtube.com/watch?v=el8E6AsMeUI" }
+---