Agent call the custom tools

[YZx0pa]

I’ve defined custom functions inside a class as a toolkit, where each function returns specific results (e.g., generated content). I’ve noticed that after the agent calls a tool and receives the tool’s response, it still sends the tool's return content along with the agent's prompt back to the model to generate the final assistant message.

Since the function output is already meaningful and can be long, I’d like to avoid sending it back to the model. Is there a way to stop the agent from re-engaging the model after a successful tool call, and instead directly use the tool’s response as the final output? Thank you!

[pritipsingh]

Hey @YZx0pa Thanks for the question- you can use something like stop_after_tool_call to stop after the function call. The stop_after_tool_call parameter in the @tool decorator allows you to control whether the agent should stop execution immediately after calling the function. When set to True, the agent will return the result of the function call and stop further processing.

Check out all the tools references here: https://docs.agno.com/tools/functions#tool-parameters-reference

We also have a cookbook on this: https://github.com/agno-agi/agno/blob/main/cookbook/agent_concepts/tool_concepts/stop_after_tool_call.py

Please let me know if you need any help here.

[YZx0pa]

Thank you for your advice, currently I defined a class of tools like below, and try to do await agent.arun(messages=user_input,stop_after_tool_call=True), but seems it doesn't stop interact with model after tool call.

class CreationTool(Toolkit):
def init(self, ):
super().init(name="Creation_Tool")

    self.register(self.add_data)
    self.register(self.modify_data)
    #####################################
    I've also tried to re-define the above as below, but the agent not able to call the tool (function), it just directly response to my input
    class CreationTool():
def __init__(self):
     pass

@tool(
name="add_data",
description="add in new data",
show_result=True,
stop_after_tool_call=True
)
async def add_data(self, data_dict: dict) -> str:
    pass

@tool(
name="modify_data",
description="update or replace an existing field in the data",
show_result=True,
stop_after_tool_call=True
)
async def modify_data(self, data_dict: dict) -> str:
    pass

[pritipsingh]

Hey @YZx0pa I tried something like this and it seems to be working well for me- do you mind sharing your full config so I can verify what's not working and where exactly it's breaking?

import random
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools import tool

class CreationTool:
    @tool(show_result=True, stop_after_tool_call=True)
    def add_data(data_dict: dict) -> str:
        """Add in new data."""
        # Implementation here
        return f"Added new data: {data_dict}"

    @tool(show_result=True, stop_after_tool_call=True)
    def modify_data(data_dict: dict) -> str:
        """Update or replace an existing field in the data."""
        # Implementation here
        return f"Modified data: {data_dict}"

# Create agent with the tools from the class
agent = Agent(
    model=OpenAIChat(id="gpt-4o-mini"),
    tools=[CreationTool.add_data, CreationTool.modify_data],
    markdown=True,
)

# Test
agent.print_response("Update the data {'name': 'John', 'age': 30}", stream=True)

[YZx0pa]

Hi @pritipsingh Thanks for the example! I see you're registering each class method as an individual tool — I believe that works fine.

In my current approach, I instantiate the class once and register the whole instance as a single toolkit:

creation_tool = CreationTool()
tools = [creation_tool]
When I define CreationTool as a subclass of Toolkit and explicitly register only the methods I want, the agent is able to call them correctly:

class CreationTool(Toolkit):
def init(self):
super().init(name="creation_tool")
self.register(self.add_data)
self.register(self.modify_data)
However, if I decorate the methods with @tool but skip self.register(...), the functions can’t be called.
I assume this is because @tool alone doesn’t automatically register class methods with the agent, and I only add tools = [CreationTool()]

I actually prefer adding the class instance as a tool (instead of individual methods), because:

1. A single class may eventually contain many helper methods.
2. I may add additional classes in the future.
3. I’d like to avoid exposing a long, flat tool list that could confuse the agent.

My concern is: if I eventually have CreationTool1, CreationTool2, etc., each with similar methods like add_data and modify_data,
will I need to register each method explicitly like this?
tools = [
CreationTool1.add_data, CreationTool1.modify_data,
CreationTool2.add_data, CreationTool2.modify_data
]
Or is there a cleaner way to handle this in Agno?

[pritipsingh]

You're right that decorating a method with @tool adds useful metadata like show_result, pre_hook, etc. — but it doesn’t automatically register the method with the agent if you’re passing the class instance (e.g. tools = [CreationTool()]).

You still need to explicitly call self.register(...) inside the class constructor to make those methods callable by the agent.

That said, you don’t need to manually list every method in tools = [...] like:

tools = [CreationTool.add_data, CreationTool.modify_data]

Instead, you can register the decorated methods once using self.register(...) inside your Toolkit subclass and then just pass the instance:

tools = [CreationTool()]

Agno’s own example demonstrates this pattern really well:
https://github.com/agno-agi/agno/blob/main/cookbook/agent_concepts/tool_concepts/custom_tools/tool_hooks_nested.py

So yes, your current approach using a single class instance + self.register(...) is the cleanest and scales well even if you have multiple toolkits like CreationTool1, CreationTool2, etc.

[YZx0pa]

HI @pritipsingh Thanks
Thanks for the advice! I tested the example you shared. When I define tools using a class instance and self.register(...), setting "tool_hooks" still doesn’t prevent the agent from using the function’s return value in its response.

1. The function returns: {"customer_id": "456", "email": "john.doe@example.com"}
2. The agent then responds:
   "Your customer profile has been retrieved. Here are the details:
   Customer ID: 456
   Email: john.doe@example.com"

I’d like to suppress this second step and stop the agent from generating a follow-up message based on the function output. Thank you!

[kausmeows]

Hi @YZx0pa, so just getting this right- by saying you want to supress the second step you dont want the agent to reply to the query? Because thats whats happening when you call print_response

You can maybe capture the run like this-

"""Show how to use multiple tool execution hooks, to run logic before and after a tool is called."""

import json
from typing import Any, Callable, Dict

from agno.agent import Agent
from agno.tools.toolkit import Toolkit
from agno.utils.log import logger


class CustomerDBTools(Toolkit):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        self.register(self.retrieve_customer_profile)
        self.register(self.delete_customer_profile)

    def retrieve_customer_profile(self, customer_id: str):
        """
        Retrieves a customer profile from the database.

        Args:
            customer_id: The ID of the customer to retrieve.

        Returns:
            A string containing the customer profile.
        """
        logger.info(f"Looking up customer profile for {customer_id}")
        return json.dumps(
            {
                "customer_id": customer_id,
                "name": "John Doe",
                "email": "john.doe@example.com",
            }
        )

    def delete_customer_profile(self, customer_id: str):
        """
        Deletes a customer profile from the database.

        Args:
            customer_id: The ID of the customer to delete.
        """
        logger.info(f"Deleting customer profile for {customer_id}")
        return f"Customer profile for {customer_id}"


def validation_hook(function_name: str, call_func: Callable, arguments: Dict[str, Any]):
    if function_name == "retrieve_customer_profile":
        cust_id = arguments.get("customer_id")
        if cust_id == "123":
            raise ValueError("Cannot retrieve customer profile for ID 123")

    if function_name == "delete_customer_profile":
        cust_id = arguments.get("customer_id")
        if cust_id == "123":
            raise ValueError("Cannot delete customer profile for ID 123")

    logger.info("Before Validation Hook")
    result = call_func(**arguments)
    logger.info("After Validation Hook")
    # Remove name from result to sanitize the output
    result = json.loads(result)
    result.pop("name")
    return json.dumps(result)


def logger_hook(function_name: str, call_func: Callable, arguments: Dict[str, Any]):
    logger.info("Before Logger Hook")
    result = call_func(**arguments)
    logger.info("After Logger Hook")
    return result


agent = Agent(
    tools=[CustomerDBTools()],
    # Hooks are executed in order of the list
    tool_hooks=[validation_hook, logger_hook],
)

if __name__ == "__main__":
    var = agent.run("retrieve_customer_profile for customer_id 456")
    print(var)
    print(var.content)
    # agent.print_response("I am customer 456, please retrieve my profile.", markdown=True)

in var.content will be agent's response and you print var you'll see in tools there will be info regarding the tool call response. So this way it directly won't print in the cli, and you can capture it in a variable and do what is needed. Let me know if that helps.

[YZx0pa]

Hi @kausmeows Thanks for you reply, In Agno, what I’m looking for is a way to stop further agent interaction after a function call is executed. I want the system to directly return the function’s result, rather than passing it back to the LLM agent for an additional reply. This behavior is similar to using @tool(show_result=True, stop_after_tool_call=True) on standalone functions. I’m trying to achieve the same effect for methods defined inside a class-based tool. Thanks!

[kausmeows]

I see @YZx0pa , We still have to build it. We added include and exclude on Toolkits, but not the rest. Adding this to feature request and we'll keep you posted. Thanks for bringing this up!!! Appreciate it

[YZx0pa]

Great thanks!