Handoffs to deterministic workflows

[almathie]

Please read this first

• Have you read the docs?Agents SDK docs yes
• Have you searched for related issues? Others may have had similar requests yes

Question

Your documentation heavily emphasises using deterministic workflows to get best results.
Examples include the llm as judge pattern to get the best possible novel outline, as well as the parallelization pattern to get the best translation.

How can I expose these workflows to a triage agents using the handoff pattern. It's quite trivial to expose those as tools; but the handoff option seems to require a whole agent, and not a simpler function so;

• Is there an option to "convert" a function that takes a prompt, follows a workflow and produces a response into an agent object that can then be exposed as a tool and/or handoff
• Is there a way to expose a function that takes a prompt and produces a response as thing that can be handoffed to?

Either one of these would allow triage agents to handoff to complex workflow instead of being limited to performing handoffs to single agents, which are less powerful than complex workflows

[apiltamang]

i don't understand, you either 'handoff' to an agent or you perform a specific task as a 'tool'. Why do you need to take a tool, and use it like an agent (thus needing to 'handoff' to a tool) ? that doesn't make sense to me right away.

[seratch]

Yeah, my impression is the same with @apiltamang. Handoffs design pattern is useful only when you want to dynamically assign the agent that is currently working on the task. As the whole workflow of the handoff history, you can achieve something meaningful.

If you want to hand off to a different "function", it sounds like you may want to have such an agent with the sufficient functionalities as its tools, plus define a clear instructions to ensure the agent to leverage the tools to achieve its goal.

If you have a specific use case scenario in mind, sharing it here would be helpful for others to better understand what you'd like to build.

[almathie]

Thanks you very much for your answers and digging into this !

Let me try to be more clear, with some code examples :)

Let's assume I am building a system that can either translate to Spanish or write a story outline. I can do this:

spanish_agent = Agent(
    name="spanish_agent",
    instructions="You translate the user's message to Spanish",
)

story_outline_generator = Agent(
    name="story_outline_generator",
    instructions=(
        "You generate a very short story outline based on the user's input."
        "If there is any feedback provided, use it to improve the outline."
    ),
)

triage_agent = Agent(
    name="triage_agent",
    instructions="Handoff to the appropriate agent based on the request of the user",
    handoffs=[spanish_agent, story_outline_generator],
)

async def main():
    msg = input("Hi! Ask me to translate something in Spanish or to write a story outline. Nothing else !")
    agent = triage_agent
    result = await Runner.run(
        triage_agent,
        input_prompt,
    )
    print result.final_output

if __name__ == "__main__":
    asyncio.run(main())

That's lovely, except if I am unsatisfied with the quality of the story_outline_generator and of the spanish_agent.

Luckily, your documentation shows me two patterns to increase the quality of each of those:

• This example shows me how to increase the quality of the story_outline_generator by creating a first draft and having few rounds of iterations before returning the results. https://github.com/openai/openai-agents-python/blob/main/examples/agent_patterns/llm_as_a_judge.py
• This example shows me how to increase the quality of the spanish_agentby running 3 agents in parallel and picking the best translation. https://github.com/openai/openai-agents-python/blob/main/examples/agent_patterns/parallelization.py

I wanna be able to handoff to each of these workflows, not just to a single agent. Something like

def translate_to_spanish
  ## Copy/paste the clever parallelization example

def write_outline
  ## Copy/paste the clever llm as judge example

triage_agent = Agent(
    name="triage_agent",
    instructions="Handoff to the appropriate agent based on the request of the user",
    handoffs=[translate_to_spanish, write_outline],
)

async def main():
    msg = input("Hi! Ask me to translate something in Spanish or to write a story outline. Nothing else !")
    agent = triage_agent
    result = await Runner.run(
        triage_agent,
        input_prompt,
    )
    print result.final_output

if __name__ == "__main__":
    asyncio.run(main())

This second version would yield much better results than the first one.

Note that if I wanna expose these two functions as tools this is easy to do and works well. But the question is about handoffs; I don't need the results from the functions to return to the triage agent, no further processing is required.