Workflows as Tools

Agent tools come in two flavors: local tools that run inside the agent handler, and workflows exposed as tools that run as separate services. This page focuses on deploying workflows as agent tools. For local tools (wrapping tool logic in ctx.run() within the agent handler), see Durable Agents.

Why expose workflows as tools?

As your agent tools grow more complex, you can extract them into separate Restate services and expose them as tools:

Scale independently: Tools can run on different infrastructure, scale separately from the agent
Any language: Write tools in a different language than the agent (e.g., Python tool called from TypeScript agent)
Long-running and async: Remote workflows can be started asynchronously without blocking the agent execution and can take minutes or hours (human approval, external processing)

All calls between the agent and its tool services are proxied via Restate, which persists the call and handles retries and recovery.

Example: human approval workflow as a tool

This example shows a human approval workflow exposed as an agent tool. The workflow creates an awakeable, sends a review request, and suspends until a human responds. The agent treats this like any other tool call.

1. Define the sub-workflow

Extract the tool logic into a separate Restate service:

Vercel AI
OpenAI Agents
Google ADK
Pydantic AI
LangChain

sub-workflow-agent.ts

export const humanApprovalWorkflow = restate.service({
  name: "HumanApprovalWorkflow",
  handlers: {
    requestApproval: async (ctx: restate.Context, claim: InsuranceClaim) => {
      const approval = ctx.awakeable<boolean>();
      await ctx.run("request-review", () =>
        requestHumanReview(claim, approval.id),
      );
      return approval.promise;
    },
  },
});

sub_workflow_agent.py

# Sub-workflow service for human approval
human_approval_workflow = restate.Service("HumanApprovalWorkflow")


@human_approval_workflow.handler()
async def review(ctx: restate.Context, claim: InsuranceClaim) -> str:
    """Request human approval for a claim and wait for response."""
    # Create an awakeable that can be resolved via HTTP
    approval_id, approval_promise = ctx.awakeable(type_hint=str)

    # Request human review
    await ctx.run_typed(
        "Request review", request_human_review, claim=claim, awakeable_id=approval_id
    )

    # Wait for human approval
    return await approval_promise

sub_workflow_agent.py

# Sub-workflow service for human approval
human_approval_workflow = restate.VirtualObject("HumanApprovalWorkflow")


@human_approval_workflow.handler()
async def review(ctx: restate.ObjectContext, claim: InsuranceClaim) -> str:
    """Request human approval for a claim and wait for response."""
    # Create an awakeable that can be resolved via HTTP
    approval_id, approval_promise = ctx.awakeable(type_hint=str)

    # Request human review
    await ctx.run_typed(
        "Request review", request_review, claim=claim, awakeable_id=approval_id
    )

    # Wait for human approval
    return await approval_promise

sub_workflow_agent.py

# Sub-workflow service for human approval
human_approval_workflow = restate.Service("HumanApprovalWorkflow")


@human_approval_workflow.handler()
async def review(ctx: restate.Context, claim: InsuranceClaim) -> str:
    """Request human approval for a claim and wait for response."""
    # Create an awakeable that can be resolved via HTTP
    approval_id, approval_promise = ctx.awakeable(type_hint=str)

    # Request human review
    await ctx.run_typed(
        "Request review", request_human_review, claim=claim, awakeable_id=approval_id
    )

    # Wait for human approval
    return await approval_promise

sub_workflow_agent.py

# Sub-workflow service for human approval.
human_approval_workflow = restate.Service("HumanApprovalWorkflow")


@human_approval_workflow.handler()
async def review(ctx: restate.Context, claim: InsuranceClaim) -> str:
    """Request human approval for a claim and wait for response."""
    approval_id, approval_promise = ctx.awakeable(type_hint=str)

    await ctx.run_typed(
        "Request review", request_human_review, claim=claim, awakeable_id=approval_id
    )

    return await approval_promise

The sub-workflow uses ctx.awakeable() to create a durable promise that can be resolved externally via HTTP. The agent suspends while waiting, freeing compute resources.

2. Call it from the agent

The agent exposes the sub-workflow as a tool. When the LLM picks it, the agent calls the remote service via Restate’s service client:

Vercel AI
OpenAI Agents
Google ADK
Pydantic AI
LangChain

sub-workflow-agent.ts

humanApproval: tool({
  description: "Ask for human approval for high-value claims.",
  inputSchema: InsuranceClaimSchema,
  execute: async (claim: InsuranceClaim) =>
    ctx.serviceClient(humanApprovalWorkflow).requestApproval(claim),
}),

Try out workflows as tools

Install Restate and launch it:

npm install --global @restatedev/restate-server@latest @restatedev/restate@latest
restate-server

Get the example:

restate example typescript-vercel-ai-tour-of-agents && cd typescript-vercel-ai-tour-of-agents
npm install

Export your OpenAI API key and run the agent:

export OPENAI_API_KEY=sk-...

npx tsx ./src/sub-workflow-agent.ts

restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations

Start a request that triggers the human approval sub-workflow:

curl localhost:8080/restate/send/SubWorkflowClaimAgent/run \
  --json '{"prompt": "Process my hospital bill of 3000USD for a broken leg."}'

In the UI, you can see the agent calling the sub-workflow and suspending while waiting for approval:

Resolve the approval by executing the curl request printed in the service logs, similar to:

curl localhost:8080/restate/awakeables/sign_1M28aqY6ZfuwBmRnmyP/resolve --json 'true'

sub_workflow_agent.py

@durable_function_tool
async def human_approval(claim: InsuranceClaim) -> str:
    """Ask for human approval for high-value claims."""
    return await restate_context().service_call(review, claim)

Try out workflows as tools

Install Restate and launch it:

restate-server

Get the example:

restate example python-openai-agents-tour-of-agents && cd python-openai-agents-tour-of-agents

Export your OpenAI API key and run the agent:

export OPENAI_API_KEY=sk-...

uv run app/sub_workflow_agent.py

restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations

Start a request that triggers the human approval sub-workflow:

curl localhost:8080/restate/send/SubWorkflowClaimAgent/run \
  --json '{"message": "Process my hospital bill of 3000USD for a broken leg."}'

In the UI, you can see the agent calling the sub-workflow and suspending while waiting for approval.Resolve the approval by executing the curl request printed in the service logs, similar to:

curl localhost:8080/restate/awakeables/sign_1M28aqY6ZfuwBmRnmyP/resolve --json 'true'

sub_workflow_agent.py

async def human_approval(claim: InsuranceClaim) -> str:
    """Ask for human approval for high-value claims."""
    return await restate_context().service_call(review, claim)

Try out workflows as tools

Install Restate and launch it:

restate-server

Get the example:

restate example python-google-adk-tour-of-agents && cd python-google-adk-tour-of-agents

Export your Google API key and run the agent:

export GOOGLE_API_KEY=your-api-key

uv run app/sub_workflow_agent.py

restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations

Start a request that triggers the human approval sub-workflow:

curl localhost:8080/restate/send/SubWorkflowClaimAgent/user-123/run \
  --json '{"message": "Process my hospital bill of 3000USD for a broken leg.", "session_id": "session-123"}'

In the UI, you can see the agent calling the sub-workflow and suspending while waiting for approval.Resolve the approval by executing the curl request printed in the service logs, similar to:

curl localhost:8080/restate/awakeables/sign_1M28aqY6ZfuwBmRnmyP/resolve --json 'true'

sub_workflow_agent.py

@agent.tool
async def human_approval(_run_ctx: RunContext[None], claim: InsuranceClaim) -> str:
    """Ask for human approval for high-value claims."""
    return await restate_context().service_call(review, claim)

Try out workflows as tools

Install Restate and launch it:

restate-server

Get the example:

restate example python-pydantic-ai-tour-of-agents && cd python-pydantic-ai-tour-of-agents

Export your OpenAI API key and run the agent:

export OPENAI_API_KEY=sk-...

uv run app/sub_workflow_agent.py

restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations

Start a request that triggers the human approval sub-workflow:

curl localhost:8080/restate/send/SubWorkflowClaimAgent/run \
  --json '{"message": "Process my hospital bill of 3000USD for a broken leg."}'

In the UI, you can see the agent calling the sub-workflow and suspending while waiting for approval.Resolve the approval by executing the curl request printed in the service logs, similar to:

curl localhost:8080/restate/awakeables/sign_1M28aqY6ZfuwBmRnmyP/resolve --json 'true'

sub_workflow_agent.py

@tool
async def human_approval(claim: InsuranceClaim) -> str:
    """Ask for human approval for high-value claims."""
    return await restate_context().service_call(review, claim)

Try out workflows as tools

Install Restate and launch it:

restate-server

Get the example:

restate example python-langchain-tour-of-agents && cd python-langchain-tour-of-agents

Export your OpenAI API key and run the agent:

export OPENAI_API_KEY=sk-...

uv run app/sub_workflow_agent.py

restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations

Start a request that triggers the human approval sub-workflow:

curl localhost:8080/restate/send/SubWorkflowClaimAgent/run \
  --json '{"message": "Process my hospital bill of 3000USD for a broken leg."}'

In the UI, you can see the agent calling the sub-workflow and suspending while waiting for approval.Resolve the approval by executing the curl request printed in the service logs, similar to:

curl localhost:8080/restate/awakeables/sign_1M28aqY6ZfuwBmRnmyP/resolve --json 'true'

​Why expose workflows as tools?

​Example: human approval workflow as a tool

​1. Define the sub-workflow

​2. Call it from the agent

Why expose workflows as tools?

Example: human approval workflow as a tool

1. Define the sub-workflow

2. Call it from the agent