Questions about Agent Behavior and Supported Patterns

[sr198]

I implemented the following dynamic workflow to understand the overall ADK capabilities and limitations.

Some observations and questions:

1. If a development request comes in, the root agent transfers the control over to PO agent (based on the provided instructions).

• Observation: You need a large model that supports function calling - I tested with Qwen3-8b which supports function calling but the behavior was very unpredictable. Had to use Gemini for this agent.

2. The PO Agent is a custom agent that saves the final requirements spec into the Artifact Service. I tested both tools and callbacks (wanted to use more than session states) to manage the artifacts but they were not really reliable (again goes back to the LLM being used and function calling capability) - so I went with custom agents. This gave me full control/deterministic behavior.

3. Once the PO Agent is done, the control got handed over to the Design Agent - this was pretty simple.

4. Issue 1 - Once this Sequential Agent was done, the control went back to the PO Agent. I was not expecting this. And since it had no instructions about handing over the control to the Development Team, the process stopped. Looking at the expected tree structure here, shouldn't the Design team have handed over control back to the root agent? I had to get involved to pass the control over to Development team.

5. All agents in the Development team are custom agents - so I didn't really have any issues here. I wanted to test dynamic creation of agents based on runtime knowledge and that's what is happening. The architect suggests a strategy for parallel work breakdown and the Scrum master agent creates 'n' number of smaller dev teams to deliver separate artifacts (this small team iterates over its results). The integration agent collects all of the outputs and creates one code bundle that then gets sent back to the user.

Other observations

1. I wish there was better support for non-Google models. There are a number of capable smallish models which support function calling that can be run locally - Qwen3 for example, but they seem to have tons of issues working with Google.
2. After this exercise, I am still not clear about using direct Agents versus Agents as tools - I know what they do but experts could you look at the above diagram and say what you would have done differently? Where would you use standalone agents, agents as tools or just tools?
3. My biggest pain-point was how tied up the architecture was with Gemini's function calling behavior - anything outside of what Gemini outputs or supports, and ADK doesn't work [the community can help here.]