Sequential Agent vs. LLM Agent in after_agent_callback - Architecture Trade-offs?

[VenkataSakethDakuri]

I'm designing an agent workflow and trying to decide between two architectural approaches for executing a specific task:

Option 1: Sequential Agent
Chain the task as a separate agent in the workflow sequence (Agent A → Agent B)

Option 2: Callback-based Agent
Execute the task using an LLM agent inside the after_agent_callback of the first agent

Both approaches achieve the same goal, but I'm unclear about the trade-offs. Specifically:

Are there performance/latency differences between these approaches?

Are there best practices or design patterns that favor one approach over the other?

Could there be issues with context propagation or token limits when nesting agents in callbacks?

Any insights on when to prefer one approach over the other would be greatly appreciated!

[adk-bot]

Response from ADK Answering Agent (experimental, answer may be inaccurate)

TLDR: For creating a sequence of tasks, the SequentialAgent is the recommended and architecturally sound approach. Using an LLM agent inside an after_agent_callback is an anti-pattern that can lead to performance issues and unnecessary complexity.

---

Hello! That's an excellent question about ADK workflow design. Here’s a breakdown of the trade-offs between the two approaches you've described.

Option 1: Sequential Agent (Recommended)

This is the idiomatic and intended way to build multi-step workflows in ADK. The SequentialAgent is a specialized "workflow agent" designed specifically to execute a list of sub-agents in a fixed order. [9, 23, 28]

• Best Practices: This pattern aligns perfectly with ADK's design principles for orchestration. It creates a clear, predictable, and maintainable pipeline where each agent has a distinct responsibility. [9, 12, 14]
• Performance: The SequentialAgent is optimized for this task. ADK manages the transition between agents, passing the context and state efficiently. The total latency is predictably the sum of the latencies of each agent in the sequence. [3]
• Context Propagation: This is handled automatically. ADK passes the same InvocationContext to each sub-agent, allowing them to communicate seamlessly through shared session state (context.state). For example, one agent can save its output using the output_key property, and the next agent can immediately use that value. [9]

Option 2: LLM Agent in after_agent_callback (Not Recommended)

Callbacks are powerful hooks for observing, customizing, and controlling an agent's behavior. [1] However, they are not designed to orchestrate major workflow steps.

• Best Practices: The primary role of an after_agent_callback is to perform synchronous, lightweight post-processing on an agent's result. [1, 4] This includes tasks like sanitizing output, logging, or modifying the final Content object. Best practices explicitly warn against putting long-running or blocking operations inside callbacks, as they can severely impact performance. [10] Executing a new LLM agent, which involves network calls and significant processing, falls into this category.
• Performance/Latency: Invoking another agent from within a callback would block the completion of the first agent's turn until the nested agent has fully executed. This adds significant latency and works against the responsive nature of the framework.
• Context Propagation: While the after_agent_callback does have access to CallbackContext and thus the session state [7, 17], manually managing the invocation of a second agent and stitching the context together is more complex and error-prone than letting the SequentialAgent orchestrator handle it. You could also face challenges with token limits if you are not careful about how the conversational history is passed to the nested agent. [18]

Conclusion

For your use case, the SequentialAgent is the clear and correct choice. It provides a robust, performant, and maintainable architecture that leverages the core strengths of the ADK framework. Reserve callbacks for their intended purpose: focused, fast operations like validation, logging, and output modification.

[1] https://google.github.io/adk-docs/callbacks/index.html
[2] https://google.github.io/adk-docs/streaming/dev-guide/part3.html
[3] https://google.github.io/adk-docs/callbacks/types-of-callbacks.html
[4] https://google.github.io/adk-docs/agents/multi-agents.html
[5] https://google.github.io/adk-docs/callbacks/design-patterns-and-best-practices.html
[6] https://google.github.io/adk-docs/get-started/about.html
[7] https://google.github.io/adk-docs/tools/feature-matrix/start.html
[8] https://google.github.io/adk-docs/agents/workflow-agents/index.html
[9] https://google.github.io/adk-docs/agents/workflow-agents/sequential-agents.html