Imran Hassanali presents a comprehensive benchmark comparing "Code Mode"—where an LLM generates complete code to execute tools—against traditional function calling for tool interactions. The results demonstrate that Code Mode is significantly more efficient, achieving 60% faster execution, 68% fewer tokens used, and an 87.5% reduction in API round trips while maintaining equal accuracy compared to regular agents.
- Evaluated using eight realistic business scenarios, including multi-client invoicing and expense tracking.
- Code Mode advantage scales with task complexity; high-complexity tasks saw up to a 79.2% speedup.
- The benchmark tested both Claude 3 Haiku (showing major efficiency gains) and Gemini 2.0 Flash Experimental.
- Secure code execution is implemented via RestrictedPython, preventing filesystem and network access during the sandbox phase.
- Evaluated using eight realistic business scenarios, including multi-client invoicing and expense tracking.
- Code Mode advantage scales with task complexity; high-complexity tasks saw up to a 79.2% speedup.
- The benchmark tested both Claude 3 Haiku (showing major efficiency gains) and Gemini 2.0 Flash Experimental.
- Secure code execution is implemented via RestrictedPython, preventing filesystem and network access during the sandbox phase.
Vinod Chugani writes about how different open-weight model families—Gemma 4, Llama 3, and Mistral—implement tool calling for local deployments.The article explores the mechanisms of function calling, which allow models to interact with external APIs or data rather than relying solely on training data, and evaluates each model's unique architectural strengths and trade-offs regarding reliability, efficiency, and developer support.
- Gemma 4 offers native agentic support with a configurable thinking mode for intermediate reasoning.
- Llama 3 models include "pythonic" tool calling variants in specific smaller versions (1B/3B).
- Mistral Small leverages Mixture-of-Experts architecture to provide high efficiency on constrained hardware.
- Gemma 4 offers native agentic support with a configurable thinking mode for intermediate reasoning.
- Llama 3 models include "pythonic" tool calling variants in specific smaller versions (1B/3B).
- Mistral Small leverages Mixture-of-Experts architecture to provide high efficiency on constrained hardware.
This article explores how tool calling enables AI agents to move beyond simple text generation by interacting with external systems. It explains the process where large language models generate structured data, such as JSON, instead of natural language to trigger specific functions and APIs.
- The mechanics of function definition within model prompts
- How reasoning leads a model to select appropriate tools for a task
- The transition from conversational responses to actionable command outputs
- The execution loop required for autonomous agent behavior
- The mechanics of function definition within model prompts
- How reasoning leads a model to select appropriate tools for a task
- The transition from conversational responses to actionable command outputs
- The execution loop required for autonomous agent behavior
An examination of the hype surrounding autonomous AI agent frameworks and why they may add unnecessary complexity to software development. The author argues that for most production use cases, structured workflows using LLM function calling are more reliable than fully autonomous agents.
- Complexity vs control in agentic systems
- Limitations of current models regarding long-term autonomy
- Advantages of explicit programming over unpredictable loops
- Complexity vs control in agentic systems
- Limitations of current models regarding long-term autonomy
- Advantages of explicit programming over unpredictable loops
The llama.cpp server has introduced support for the Anthropic Messages API, a highly requested feature that allows users to run Claude-compatible clients with locally hosted models. This implementation enables powerful tools like Claude Code to interface directly with local GGUF models by internally converting Anthropic's message format to OpenAI's standard. Key features of this update include full support for chat completions with streaming, advanced tool use through function calling, token counting capabilities, vision support for multimodal models, and extended thinking for reasoning models. This development bridges the gap between proprietary AI ecosystems and local, privacy-focused inference pipelines, providing a seamless experience for developers working with agentic workloads and coding assistants.
ANTHROPIC_AUTH_TOKEN, ANTHROPIC_MODEL=
ANTHROPIC_AUTH_TOKEN, ANTHROPIC_MODEL=
This article explains how to implement function calling with Google’s Gemma 3 27B model. It covers the concept of function calling, the step‑by‑step workflow, and provides a practical example using a Python `convert` function to turn $200,000 into EUR. The post walks through prompting Gemma, parsing its `tool_code` output, executing the function with `eval`, and returning a friendly final response. It also demonstrates how to set up the Google‑GenAI SDK, create a chat session, and extract tool calls. The discussion highlights Gemma’s multilingual, multimodal, and agentic capabilities, making it suitable for real‑world AI assistants that need to interact with external APIs and tools.
This guide explains how to use tool calling with local LLMs, including examples with mathematical, story, Python code, and terminal functions, using llama.cpp, llama-server, and OpenAI endpoints.
This article compares Model Context Protocol (MCP), Function Calling, and OpenAPI Tools for integrating tools and resources with language models, outlining their strengths, limits, security considerations, and ideal use cases.
This document details the features, best practices, and migration guidance for GPT-5, OpenAI's most intelligent model. It covers new API features like minimal reasoning effort, verbosity control, custom tools, and allowed tools, along with prompting guidance and migration strategies from older models and APIs.
LLM 0.26 introduces tool support, allowing LLMs to access and utilize Python functions as tools. The article details how to install, configure, and use these tools with various LLMs like OpenAI, Anthropic, Gemini, and Ollama models, including examples with plugins and ad-hoc functions. It also discusses the implications for building 'agents' and future development plans.
