OpenAI Function Calling: The Complete Guide for Agent Builders (2026)

How Function Calling Works

Function calling is a conversation protocol between your application and an OpenAI model. You tell the model what functions exist and what arguments they accept. The model decides whether to call a function based on the user's message. If it does, your application executes the function and feeds the result back. The model then uses that result to generate its final response.

The model never executes code itself. It generates a JSON object containing the function name and arguments. Your application parses that JSON, runs the actual function, and returns the output. This separation is what makes function calling safe and controllable: you decide which functions to expose, validate every argument, and control execution.

The Five-Step Loop

Every function calling interaction follows the same pattern, whether you're building a simple weather bot or a full coding agent.

const response = await openai.responses.create({
  model: "gpt-5",
  input: [{ role: "user", content: "What files are in the src directory?" }],
  tools: [{
    type: "function",
    name: "list_files",
    description: "List files in a directory",
    parameters: {
      type: "object",
      properties: {
        path: {
          type: "string",
          description: "The directory path to list"
        },
        recursive: {
          type: "boolean",
          description: "Whether to list files recursively"
        }
      },
      required: ["path"],
      additionalProperties: false
    },
    strict: true
  }]
});

// Model returns a function_call output item
const toolCall = response.output.find(
  item => item.type === "function_call"
);

if (toolCall) {
  const args = JSON.parse(toolCall.arguments);
  const result = listFiles(args.path, args.recursive);

  // Send the result back
  const finalResponse = await openai.responses.create({
    model: "gpt-5",
    input: [
      { role: "user", content: "What files are in the src directory?" },
      toolCall,  // the function_call from the model
      {
        type: "function_call_output",
        call_id: toolCall.call_id,
        output: JSON.stringify(result)
      }
    ],
    tools: [/* same tools array */]
  });
}

Strict Mode and Schema Enforcement

Without strict mode, OpenAI models generate function arguments on a best-effort basis. They usually get the schema right, but not always. A model might omit a required field, use a string where you expected a number, or add properties you didn't define. In production, "usually right" isn't good enough.

Setting strict: true in your function definition enables constrained decoding. The model's token generation is restricted to outputs that are valid against your schema. This guarantees 100% schema compliance, not as a post-hoc validation, but at the generation level.

Requirements for Strict Mode

Parallel Tool Calls

A model can return multiple tool calls in a single response. If a user asks "What's the weather in Tokyo and New York?", the model returns two function_call items rather than calling one, waiting for the result, and calling the other. Your application executes both in parallel and sends both results back in a single request.

This matters for agents. A coding agent that needs to read three files doesn't need three round trips. It issues three read_file calls simultaneously. The reduction in latency scales linearly with the number of parallel calls.

// Model returns multiple function_call items
const toolCalls = response.output.filter(
  item => item.type === "function_call"
);

// Execute all calls in parallel
const results = await Promise.all(
  toolCalls.map(async (call) => {
    const args = JSON.parse(call.arguments);
    const result = await executeFunction(call.name, args);
    return {
      type: "function_call_output" as const,
      call_id: call.call_id,
      output: JSON.stringify(result)
    };
  })
);

// Send all results back in one request
const finalResponse = await openai.responses.create({
  model: "gpt-5",
  input: [
    ...previousMessages,
    ...toolCalls,
    ...results
  ],
  tools: [/* same tools */]
});

Structured Outputs vs Function Calling

These are two different features that solve two different problems. The confusion exists because both involve JSON schemas, and structured outputs can be used inside function calling (via strict mode). Here's the distinction.

If you need the model to do something (call an API, run a command, edit a file), use function calling. If you need the model to format something (extract structured data from text, return a classification), use structured outputs. Many agent architectures use both: function calling for tool invocation, structured outputs for parsing tool results into a consistent format.

Function Calling vs MCP

Function calling and MCP (Model Context Protocol) operate at different layers. Function calling is the mechanism a model uses to invoke a tool. MCP is the protocol for discovering, connecting to, and managing tools across providers.

MCP uses function calling under the hood. When an MCP client connects to a server, it discovers available tools and translates them into the model's native function calling format. The model calls tools using its own API (OpenAI's tools parameter, Anthropic's tool_use), and the MCP client routes the invocation to the correct server.

Building a Coding Agent with Function Calling

A coding agent is a loop: the model reads context, decides which tool to call, your application executes the tool, and the result goes back to the model. The quality of the agent depends on three things: the model's ability to select the right tool, the quality of your tool implementations, and how efficiently you manage context.

The typical coding agent exposes 5-15 tools. More tools means more decisions for the model, and accuracy drops as the tool count rises. OpenAI recommends fewer than 20 tools available at any given time.

Core tools for a coding agent

const tools = [
  { type: "function", name: "read_file", strict: true,
    description: "Read the contents of a file",
    parameters: {
      type: "object",
      properties: {
        path: { type: "string", description: "File path relative to project root" }
      },
      required: ["path"], additionalProperties: false
    }},
  { type: "function", name: "apply_edit", strict: true,
    description: "Apply a targeted edit to a file using Morph Fast Apply",
    parameters: {
      type: "object",
      properties: {
        path: { type: "string", description: "File path to edit" },
        original: { type: "string", description: "The original code to be replaced" },
        updated: { type: "string", description: "The new code to insert" }
      },
      required: ["path", "original", "updated"], additionalProperties: false
    }},
  { type: "function", name: "run_command", strict: true,
    description: "Execute a shell command and return stdout/stderr",
    parameters: {
      type: "object",
      properties: {
        command: { type: "string", description: "The shell command to run" }
      },
      required: ["command"], additionalProperties: false
    }}
];

async function agentLoop(task: string) {
  let messages = [{ role: "user", content: task }];

  while (true) {
    const response = await openai.responses.create({
      model: "gpt-5", input: messages, tools
    });

    const toolCalls = response.output.filter(
      item => item.type === "function_call"
    );

    if (toolCalls.length === 0) break; // Model is done

    // Execute tools in parallel
    const results = await Promise.all(
      toolCalls.map(call => executeAndFormat(call))
    );

    messages = [...messages, ...toolCalls, ...results];
  }
}

Wiring Morph Tools into Function Calling

Morph's APIs are designed as function-callable tools. They solve three problems coding agents face: applying edits accurately to existing files, searching large codebases without exhausting context, and executing code in sandboxed environments.

Fast Apply

When a coding model generates an edit, it typically produces either a full-file rewrite or a diff. Full rewrites waste tokens. Diffs are fragile: a single wrong line number breaks the patch. Morph Fast Apply takes the original file and a description of the change, then produces the edited file at 10,500 tok/s. It handles fuzzy matching, so the model doesn't need perfect line-level precision.

{
  type: "function",
  name: "fast_apply",
  strict: true,
  description: "Apply a code edit to a file. Takes the original file content and a description or snippet of the desired change. Returns the complete updated file.",
  parameters: {
    type: "object",
    properties: {
      original_code: {
        type: "string",
        description: "The current contents of the file"
      },
      edit_snippet: {
        type: "string",
        description: "The edit to apply. Can be a diff, a code snippet with changes, or a natural language description of the change."
      },
      filename: {
        type: "string",
        description: "The filename, used for language detection"
      }
    },
    required: ["original_code", "edit_snippet", "filename"],
    additionalProperties: false
  }
}

WarpGrep

Cognition measured that their Devin agent spends 60% of its time on code search. Inefficient search means wasted tokens and stale context. WarpGrep is an agentic code search tool that runs 8 parallel searches per turn over 4 turns, finding relevant code in sub-6 seconds. It works as an MCP server or a direct function tool.

Sandboxes

Code execution needs isolation. Morph Sandboxes provide ephemeral Linux environments with sub-50ms cold starts. Your agent's run_command tool routes to a sandbox instead of your host machine. Each sandbox gets its own filesystem, network namespace, and resource limits.

Best Practices

Frequently Asked Questions

What is OpenAI function calling?

Function calling lets OpenAI models invoke external functions you define. You provide a JSON schema describing available functions, the model decides when to call them and with what arguments, and your application executes the function and returns the result. It's the mechanism that turns a language model into an agent capable of reading files, calling APIs, and executing code.

What is the difference between function calling and structured outputs?

Function calling makes the model invoke a tool. Your code executes the tool and returns results. Structured outputs make the model format its text response as JSON. No execution happens. Use function calling when the model needs to take actions. Use structured outputs when you need predictable response formatting for downstream parsing.

What is strict mode in OpenAI function calling?

Setting strict: true guarantees the model's function arguments exactly match your JSON schema. It uses constrained decoding at the token level, not post-hoc validation. This requires additionalProperties: false on every object and all fields in the required array. OpenAI recommends it for all production use.

How does function calling relate to MCP?

Function calling is the invocation mechanism. MCP is the discovery and transport protocol. MCP servers expose tools through a standardized interface. The model's function calling format is used under the hood to invoke those tools. You don't choose between them. MCP uses function calling, and adds a vendor-neutral layer for tool portability across models and providers.

Which OpenAI models support function calling?

GPT-5, GPT-5.1, GPT-4o, o3, o4-mini, and GPT-4 Turbo all support function calling. The o3 and o4-mini reasoning models call tools within their chain of thought, which means tool results inform the reasoning process directly. GPT-5.1 is the strongest model for coding agent workloads as of April 2026.

Can OpenAI models call multiple functions at once?

Yes. The model can return multiple function_call items in a single response. Your application executes them in parallel and sends all results back together. Disable this with parallel_tool_calls: false when calls have dependencies. Reasoning models sometimes sequence calls naturally when step order matters.