Tools Overview

All tools implement the tool.Tool interface:

type Tool interface {
    Name() string
    Description() string
}

Function tools additionally implement tool.FuncTool:

import "context"

type FuncTool interface {
    Tool
    Schema() any
    ReturnSchema() any
    Call(ctx context.Context, arguments string) (any, error)
}

Most applications create function tools with functool.New or functool.MustNew rather than implementing FuncTool directly. The framework uses the Go function signature or struct tags to build the schema exposed to the model.

Pass tools to the agent via agent.Config.Tools:

a := foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
    Instructions: "You are a helpful assistant.",
    Config: agent.Config{
        Tools: []tool.Tool{weatherTool, calculatorTool},
    },
})

Or add tools per-run:

resp, err := a.RunText(ctx, "What's the weather?", agent.WithTool(weatherTool)).Collect()

For Go, mark an invocable tool with tool.ApprovalRequiredFunc or use a tool that already implements tool.ApprovalRequiredTool, such as the local shell tool. Approval requests and responses flow through the tool auto-call middleware, so they work with providers that return local function calls.

Provider Support Matrix

The OpenAI and Azure OpenAI providers each offer two client types — Responses and Chat Completion — with different tool capabilities. Azure OpenAI clients mirror their OpenAI equivalents. Copilot Studio and A2A agents run on a remote service so their capabilities are configured on the remote agent rather than through the Agent Framework client — they are not listed in the matrix.

Provider Support Matrix

The OpenAI and Azure OpenAI providers each offer multiple client types with different tool capabilities. Azure OpenAI clients mirror their OpenAI equivalents. The Foundry column applies to FoundryChatClient — for FoundryAgent, the tools are configured on the Foundry agent definition (see What works and what doesn't with FoundryAgent). Copilot Studio and A2A agents run on a remote service so their capabilities are configured on the remote agent rather than through the Agent Framework client — they are not listed in the matrix.

¹ Depends on the chosen local model supporting function calling. ² Built into the GitHub Copilot CLI runtime, gated by a permission handler. Different surface from OpenAI's get_shell_tool.

Provider Support Matrix

The Go SDK exposes Microsoft Foundry through foundryprovider and OpenAI/Azure OpenAI through openaiprovider. Hosted tools in tool/hostedtool are declarations: the Go SDK sends them to the provider, and the provider decides whether that hosted capability is available.

Call .AsAIFunction() on an AIAgent to convert it to a function tool that can be provided to another agent:

// Create the inner agent with its own tools
AIAgent weatherAgent = new AIProjectClient(
    new Uri("<your-foundry-project-endpoint>"),
    new DefaultAzureCredential())
     .AsAIAgent(
        model: "gpt-4o-mini",
        instructions: "You answer questions about the weather.",
        name: "WeatherAgent",
        description: "An agent that answers questions about the weather.",
        tools: [AIFunctionFactory.Create(GetWeather)]);

// Create the main agent and provide the inner agent as a function tool
AIAgent agent = new AIProjectClient(
    new Uri("<your-foundry-project-endpoint>"),
    new DefaultAzureCredential())
     .AsAIAgent(
        model: "gpt-4o-mini",
        instructions: "You are a helpful assistant.",
        tools: [weatherAgent.AsAIFunction()]);

// The main agent can now call the weather agent as a tool
Console.WriteLine(await agent.RunAsync("What is the weather like in Amsterdam?"));

Call .as_tool() on an agent to convert it to a function tool that can be provided to another agent:

import os
from agent_framework.openai import OpenAIChatCompletionClient
from azure.identity import AzureCliCredential

# Create the inner agent with its own tools
weather_agent = OpenAIChatCompletionClient(
    model=os.environ["AZURE_OPENAI_CHAT_COMPLETION_MODEL"],
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
    credential=AzureCliCredential(),
).as_agent(
    name="WeatherAgent",
    description="An agent that answers questions about the weather.",
    instructions="You answer questions about the weather.",
    tools=get_weather
)

# Create the main agent and provide the inner agent as a function tool
main_agent = OpenAIChatCompletionClient(
    model=os.environ["AZURE_OPENAI_CHAT_COMPLETION_MODEL"],
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
    credential=AzureCliCredential(),
).as_agent(
    instructions="You are a helpful assistant.",
    tools=weather_agent.as_tool()
)

# The main agent can now call the weather agent as a tool
result = await main_agent.run("What is the weather like in Amsterdam?")
print(result.text)

You can also customize the tool name, description, and argument name:

weather_tool = weather_agent.as_tool(
    name="WeatherLookup",
    description="Look up weather information for any location",
    arg_name="query",
    arg_description="The weather query or location"
)

Wrap an agent with agenttool.New to make it available as a tool.FuncTool for another agent:

import (
    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/provider/foundryprovider"
    "github.com/microsoft/agent-framework-go/tool"
    "github.com/microsoft/agent-framework-go/tool/agenttool"
)

weatherAgent := foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
    Instructions: "You answer questions about the weather.",
    Config: agent.Config{
        Name:        "WeatherAgent",
        Description: "An agent that answers weather questions.",
        Tools:       []tool.Tool{weatherTool},
    },
})

mainAgent := foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
    Instructions: "You are a helpful assistant.",
    Config: agent.Config{
        Tools: []tool.Tool{agenttool.New(weatherAgent, agenttool.Config{})},
    },
})

resp, err := mainAgent.RunText(ctx, "Should I bring an umbrella to Amsterdam?").Collect()

You can also expose the same wrapped agent through MCP with mcptool.AddTool, because agenttool.New returns a function tool.