Tool Provider for individual AI Agent (Dynamic tool discovery)

[Mohanr1122]

Is it possible in Microsoft Agent Framework to defer tool binding until execution time—by selecting relevant tools dynamically (e.g., via semantic search over tool metadata) instead of predefining them during agent initialization? If not, what are the recommended design patterns to achieve similar behavior?
Ex. In a handoff workflow, tools should be dynamically fetched, filtered, and assigned only at the time the respective agent is invoked.

[spdr870]

I am using this for loading agent skills. Related topic: #4239

I found 2 options for dynamic tools loading. In the examples below, tools are also filtered based on user authorization.

Option one, in a tool, like the example below. Each 'turn' the tools will be reset.

[Description(@"Load skill instructions and tools.")]
public void LoadSkill(string skillName)
{
	var identity = _identityProvider.GetIdentity();

	var skill = _skillsStore.GetSkill(skillName);

	var skillContent = _skillLoader.ReadSkillContent(skill);

	var functionService = FunctionInvokingChatClient.CurrentContext!;

	var filteredTools = _toolStore.GetAllTools().Where(t => skill.AllowedTools?.Any(a => a.Matches(t.Name)) == true);

	foreach (var tool in filteredTools)
	{
		if (ToolAuthorizedForIdentity(identity, tool))
			functionService.Options!.Tools!.Add(tool);
	}

	functionService!.Options!.Instructions = functionService.Options.Instructions  + "\n\n" + skillContent;
}

Option two, using AIContextProvider. Also in this case, each 'turn' the tools will be reset.

public class AgentContextProvider : AIContextProvider
{
	private readonly IdentityProvider _identityProvider;

	private readonly SkillsStore _skillStore;
	private readonly SkillLoader _skillLoader;
	private readonly ToolStore _toolStore;
	private readonly IChatClient _chatClient;

	public string _lastSelectedSkill { get; set; } = "No Skill";

	public AgentContextProvider(IChatClient chatClient, IdentityProvider identityProvider, ToolStore toolStore, SkillsStore skillStore, SkillLoader skillLoader)
	{
		_identityProvider = identityProvider;

		_skillStore = skillStore;
		_toolStore = toolStore;
		_skillLoader = skillLoader;
		_chatClient = chatClient;
	}

	public override async ValueTask<AIContext> InvokingAsync(InvokingContext context, CancellationToken cancellationToken = default)
	{
		var identity = _identityProvider.GetIdentity();

		string inputMessage = string.Join(",", context.RequestMessages.Select(m => m.Text));

		string skillPrompt = SkillsPromptTemplates.GenerateSkillsPrompt(_skillStore, _lastSelectedSkill);

		List<ChatMessage> chatMessages = [
			new ChatMessage(ChatRole.System, skillPrompt),
			new ChatMessage(ChatRole.User, inputMessage)
		];

		var skillPromptResponse = await _chatClient.GetResponseAsync(chatMessages, cancellationToken: cancellationToken);

		var skillToSelect = skillPromptResponse.Text;

		var skill = _skillStore.AllSkills.FirstOrDefault(s => string.Equals(s.Name, skillToSelect, StringComparison.OrdinalIgnoreCase));

		if (skill == null)
		{
			return new AIContext()
			{
				Instructions = "No matching skill found for the user's request, return that you do not have the skill for this."
			};
		}

		_lastSelectedSkill = skill.Name;

		var skillContent = _skillLoader.ReadSkillContent(skill);

		var allTools = _toolStore.GetAllTools();
		var filteredTools = allTools.Where(t => skill.AllowedTools?.Any(a => a.Matches(t.Name)) == true);

		return new AIContext
		{
			Instructions = skillContent,
			Tools = filteredTools.ToList()
		};
	}
}

[ishita-0301]

I don't think that's natively supported today. I'd probably put a router in front of the agent that picks the relevant tools first, then invokes the agent with just that subset.

As the number of tools grows, having runtime checks also helps avoid bad tool selection or retry loops. I've been keeping an eye on https://github.com/FailproofAI/failproofai for that reason.