Feature Request: Allow Workflow as Sub-Agents in ADK 2.0

[ruben-cid]

Workflow as Sub-Agent

Target: ADK 2.0 (Beta) — enable Workflow in LlmAgent.sub_agents for conversation delegation.

---

Problem

ADK 2.0 only supports Workflow → Agent (via ctx.run_node()). The inverse — Agent → Workflow — is not possible. This forces an all-or-nothing adoption: either convert everything to workflows or lose deterministic pipelines.

Cost impact: Workflow-root loops generate 7 events/3 LLM calls for data gathering. Sub-agent delegation would reduce to 5 events/2 LLM calls (30% reduction via event compaction on Agent Runtime).

---

Proposed Solution

Allow Workflow as a sub-agent via delegation:

from google.adk import LlmAgent, Workflow
from google.adk.workflow import node

@node(rerun_on_resume=True)
async def data_collection_workflow(ctx, request):
    amount = await ctx.run_node(request_amount_node)  # HITL via RequestInput
    date = await ctx.run_node(request_date_node)
    return {"amount": amount, "date": date}

expense_agent = LlmAgent(
    name="expense_agent",
    instruction="Delegate to collect_data if fields missing.",
    sub_agents=[
        Workflow(name="collect_data", edges=[("START", data_collection_workflow)])
    ],
)

Benefits:

• Conversation delegation with HITL support (RequestInput)
• Workflow events scoped/contained for compaction
• Hybrid architecture: agents orchestrate, workflows handle determinism

---

Representative Examples

1. Guided Form Collection

Main agent identifies required fields; workflow deterministically collects each with validation.

@node(rerun_on_resume=True)
async def onboarding_workflow(ctx, user_request):
    email = await ctx.run_node(collect_email_node)      # Validate format
    company = await ctx.run_node(collect_company_node)  # Check against DB
    role = await ctx.run_node(collect_role_node)        # HITL selection
    return {"email": email, "company": company, "role": role}

onboarding_agent = LlmAgent(
    name="onboarding_agent",
    instruction="Welcome users. If profile incomplete, delegate to onboarding_workflow.",
    sub_agents=[Workflow(name="onboarding_workflow", edges=[("START", onboarding_workflow)])],
)

2. Compliance Verification

Main agent prepares submission; workflow runs deterministic checks with human approval gates.

@node(rerun_on_resume=True)
async def compliance_workflow(ctx, submission):
    auto_check = await ctx.run_node(automated_policy_check)
    if auto_check.risk_score > 0.7:
        approval = await ctx.run_node(request_manager_approval)  # HITL
    return {"approved": auto_check.passed and approval.value == "yes"}

hr_agent = LlmAgent(
    name="hr_agent",
    instruction="Process leave requests. Delegate to compliance_workflow for policy checks.",
    sub_agents=[Workflow(name="compliance_workflow", edges=[("START", compliance_workflow)])],
)

3. Multi-Step Configuration

Agent understands intent; workflow guides through deterministic setup with confirmation steps.

@node(rerun_on_resume=True)
async def setup_workflow(ctx, intent):
    region = await ctx.run_node(select_region_node)      # HITL: dropdown
    tier = await ctx.run_node(select_tier_node)        # HITL: pricing
    confirm = await ctx.run_node(confirm_provision_node) # HITL: yes/no
    return {"region": region, "tier": tier, "confirmed": confirm}

infra_agent = LlmAgent(
    name="infra_agent",
    instruction="Provision resources. Delegate to setup_workflow for configuration.",
    sub_agents=[Workflow(name="setup_workflow", edges=[("START", setup_workflow)])],
)

---

Comparison

Pattern	LangGraph	ADK 2.0 Current	Proposed
Graph as Root	✅	✅	✅
Agent in Graph	✅	✅	✅
Graph as SubAgent	✅ bind_tools([graph])	❌	🎯

LangGraph allows graphs as callables. ADK needs equivalent: Workflow as delegatable sub-agent.

---

Considerations

• Event compaction: Sub-workflow events can be compacted; only I/O top-level
• Resumability: Workflow checkpoints within parent session

---

Docs: Dynamic Workflows | Graph-based Workflows

[markns]

I've also found myself wanting to spawn workflows as sub-agents. My use case is a pretty standard SaaS copilot type of agent, able to answer questions about the user's account, and take action on their behalf when instructed conversationally.

So far, I'm been using a task-mode agent as the first node in the workflow, which does intent routing to a child workflows. This works quite nicely, but it loses the generality of a chat-mode agent.

I notice in the ADK V2 skills (super handy resource btw) that Workflow Cannot Be a Sub-Agent of LlmAgent. So this is clearly by design at this stage, but it would be great to get some guidance from the ADK team if this is a limitation that will be fixed in future, or there's a different pattern that we should consider.

(cc @swapydapy - apologies for the direct tag, but I watched the community call, and it seems like you might be the right person to ask 🙏 )

[DeanChensj]

Will node as a tool solve your use cases?

[ViktorVeselov]

Agreed with this statment.

[swapydapy]

An Agent can be thought of as an entity which the user can free-form interact with, there's no pre-defined goal. While Workflows are more like Tools. They are designed with a pre-defined goal in mind and when invoked, they follow a defined execution path to achieve that goal.

We are in the process of supporting using Node as a Tool. That should allow using Workflows or any other custom node to be used tools in an LlmAgent.

[markns]

As long as it's still possible to use RequestInput/HITL with a workflow as agent tool, this sounds great. Even better if it's possible to enable task mode agents as nodes in a workflow tool.

[ViktorVeselov]

I see the idea, but one issue is that it can be treated strictly as a tool. A major drawback with this specific idea/implementation is production overhead. It is much simpler, easier, and more scalable to use n8n (or build yourself) and define that workflow as a tool instead.

As a mental exercise, let's say we did that and now have a workflow acting as a sub-agent. If we want to make it production-grade or integrate it with other parts of adk(which we kind of have to do), for example, adding flags and dynamically adding or subtracting elements. We also have to consider the integration side, especially if we are using an A2A (agent-to-agent/app-to-app) protocol. At the very least, we need to have a conversation about how those workflows would integrate and how to make it as painless yet secure as possible. So while I see the point, I don't think this approach will pass review. There are just too many potential risks and existing solutions. The best case is a Node as a tool.

[ViktorVeselov]

It does not mean it is not beneficial, but the implementation itself is more delicate.

[deepakbatham572]

Any update ?

[deepakbatham572]

@surajksharma07