Instruction seems to be ignored in back to back agent calls with tool output

[nicolas-chaulet]

Initial Checks

• I confirm that I'm using the latest version of Pydantic AI
• I confirm that I searched for my issue in https://github.com/pydantic/pydantic-ai/issues before opening this issue

Description

When running two agents one after the next and passing the conversation history from the first to the second AND the second outputs structured output AND there is no user prompt, instructions of the second agent are ignored and the first agent's instructions are used instead. Removing the structured output or passing a user prompt fixes the issue for some reason. Code to reproduce below with logfire trace, you'll notice that the agent.run spans are correct but the second nested openai gpt call is not

Example Code

from pydantic import BaseModel, Field
from pydantic_ai import Agent


class Suggestions(BaseModel):
    """Suggestion for what the user might want to do next. Suggest things based on previous action and what you can do for them."""

    suggestion: str = Field(..., description="Should be very short (a few words)")


agent1 = Agent("openai:gpt-4.1-nano", instructions="You are a first helpful assistant.")
agent2 = Agent(
    "openai:gpt-4.1-nano",
    instructions="You are a second helpful assistant.",
    output_type=Suggestions,
)

import logfire

# configure logfire
logfire.configure(send_to_logfire="if-token-present")
logfire.instrument_pydantic_ai()
logfire.instrument_google_genai()


class LinearWorkflow:
    """A workflow that runs a sequence of agents linearly, passing the output of one as input to the next."""

    def __init__(self, agents) -> None:
        self._agents = agents

    async def run(
        self,
        *,
        message_history,
    ):
        with logfire.span("LinearWorkflow.run"):
            current_history = [*message_history] or []  # Don't mutate input list

            for agent in self._agents:
                result = await agent.run(
                    message_history=current_history,
                )
                current_history.extend(result.new_messages())

            return result


async def bug_multi_agent() -> Agent[None, None]:
    workflow = LinearWorkflow([agent1, agent2])
    result = await workflow.run(
        message_history=[
            {"role": "user", "content": "Hello, how are you?"},
        ],
    )
    print("Final output:", result.output)


if __name__ == "__main__":
    import asyncio

    asyncio.run(bug_multi_agent())


# Public logfire trace:
# https://logfire-eu.pydantic.dev/public-trace/2572b9ff-0097-4722-ba56-062ff3ec29a2?spanId=db9af09001760713

Python, Pydantic AI & LLM client version

Pydantic AI 1.2.0

[dsfaccini]

I can confirm this behavior, here's my logfire span (I added a "Whatever you reply, include the word [A1]" to the prompt to double check which instructions were being used but agent2 still doesn't use the "safeword" in the json content)

Looking at this with claude it seems that when both conditions are met (no user prompt and a required output type) the _agent_graph.py ends up following a flow that ignores Agent2's instructions.

It follows right into an edge case that @dmontagu foresaw here and here

To your question

Removing the structured output or passing a user prompt fixes the issue for some reason.

1. When you provide a user_prompt, the code in UserPromptNode.run() doesn't take the shortcut to CallToolsNode. Instead, it creates a fresh ModelRequest with Agent2's instructions and the user's prompt. This new request has Agent2's instructions set correctly.
2. Without output_type, Agent2 still skips to CallToolsNode (because there's no user_prompt). CallToolsNode sees a plain text response, processes it, and returns End(final_result) - terminating the agent run immediately.

Summarized: when you provide a user prompt Agent2 says "let's get working, there's a prompt for us to process". When you don't require an output type, the Agent2 sees the message history and thinks "I already answered".

The important thing to highlight about point 2 is: Agent2 never makes its own model request at all; it just returns Agent1's response as its own output. So this "workaround" doesn't actually make Agent2 use its own instructions, it just skips the entire Agent2 execution and uses Agent1's output directly. Is this something you checked @nicolas-chaulet?

I opened a PR with claude #3209. It's a draft because I know this needs discussion, just wanted to put forth a solution.

Happy Tuesday!
David

[nicolas-chaulet]

Thanks for confirming! And yes you are correct without output_type the second agent does not even run

[DouweM]

Thanks for the report @nicolas-chaulet and the PR @dsfaccini! I've left a review.