> ## Documentation Index > Fetch the complete documentation index at: https://docs.restate.dev/llms.txt > Use this file to discover all available pages before exploring further. ## Submitting Feedback If you encounter incorrect, outdated, or confusing documentation on this page, submit feedback: POST https://docs.restate.dev/feedback ```json { "path": "/ai/patterns/human-in-the-loop", "feedback": "Description of the issue" } ``` Only submit feedback when you have something specific and actionable to report. # Approvals with Pause & Resume > Agents that pause for human approval and resume when it arrives, even across restarts and infrastructure changes. export const GitHubLink = ({url}) =>

{ e.target.style.color = '#6B7280'; e.target.style.backgroundColor = '#F9FAFB'; }} onMouseOut={e => { e.target.style.color = '#6B7280'; e.target.style.backgroundColor = 'transparent'; }}> View on GitHub

; export const GlobalTab = ({title, icon, children}) => { return

{children}

; }; export const GlobalTabs = ({children, className = ''}) => { const [activeTab, setActiveTab] = useState(0); const tabs = React.Children.toArray(children).filter(child => child.type && child.type.name === 'GlobalTab'); useEffect(() => { const savedLanguage = localStorage.getItem('language'); if (savedLanguage) { const matchingIndex = tabs.findIndex(tab => tab.props.title === savedLanguage); if (matchingIndex !== -1) { setActiveTab(matchingIndex); } } }, [tabs]); useEffect(() => { const handleGlobalTabChange = event => { const targetTitle = event.detail.title; const matchingIndex = tabs.findIndex(tab => tab.props.title === targetTitle); if (matchingIndex !== -1 && matchingIndex !== activeTab) { setActiveTab(matchingIndex); } }; window.addEventListener('globalTabChange', handleGlobalTabChange); return () => window.removeEventListener('globalTabChange', handleGlobalTabChange); }, [tabs, activeTab]); const handleTabClick = index => { setActiveTab(index); const title = tabs[index].props.title; localStorage.setItem('language', title); window.dispatchEvent(new CustomEvent('globalTabChange', { detail: { title } })); }; return

{tabs[activeTab]?.props.children}

; }; Some agent actions need human approvals for dangerous actions: deploying code, sending money, modifying user accounts. With Restate, your agent can **pause** execution, wait for an external signal, and **resume** exactly where it left off, even if the process restarts in the meantime. ## How it works Restate provides **durable promises** (awakeables) that survive crashes and restarts: 1. The agent creates a durable promise and gets a unique ID 2. The agent sends this ID to whoever needs to approve (Slack, email, dashboard) 3. The agent **suspends**, freeing compute resources (no idle billing on serverless) 4. When the approver responds, they resolve the promise via HTTP 5. The agent **resumes** from the exact point it paused ## Example: approval tool for an agent ```typescript human-approval-agent.ts {"CODE_LOAD::https://raw.githubusercontent.com/restatedev/ai-examples/refs/heads/main/vercel-ai/tour-of-agents/src/human-approval-agent.ts#here"} theme={null} const run = async (ctx: restate.Context, { prompt }: ClaimPrompt) => { const model = wrapLanguageModel({ model: openai("gpt-4o"), middleware: durableCalls(ctx, { maxRetryAttempts: 3 }), }); const { text } = await generateText({ model, system: "You are an insurance claim evaluation agent. Use these rules: " + "* if the amount is more than 1000, ask for human approval, " + "* if the amount is less than 1000, decide by yourself", prompt, tools: { humanApproval: tool({ description: "Ask for human approval for high-value claims.", inputSchema: InsuranceClaimSchema, execute: async (claim: InsuranceClaim): Promise => { const approval = ctx.awakeable(); await ctx.run("request-review", () => requestHumanReview(claim, approval.id), ); return approval.promise; }, }), }, stopWhen: [stepCountIs(5)], providerOptions: { openai: { parallelToolCalls: false } }, }); return text; }; ``` [Install Restate](/installation) and launch it: ```bash theme={null} npm install --global @restatedev/restate-server@latest @restatedev/restate@latest restate-server ``` Get the example: ```bash theme={null} restate example typescript-vercel-ai-tour-of-agents && cd typescript-vercel-ai-tour-of-agents npm install ``` Export your [OpenAI API key](https://platform.openai.com/api-keys) and run the agent: ```bash theme={null} export OPENAI_API_KEY=sk-... ``` ```bash theme={null} npx tsx ./src/human-approval-agent.ts ``` Register the agents with Restate: ```bash theme={null} restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations ``` Use `curl` with `/send` to start the claim asynchronously, without waiting for the result: ```bash theme={null} curl localhost:8080/HumanClaimApprovalAgent/run/send \ --json '{"prompt": "Process my hospital bill of 3000USD for a broken leg."}' ``` You can restart the service to see how Restate continues waiting for the approval. If you wait for more than a minute, the invocation will get suspended. Invocation overview

Simulate approving the claim by executing the **curl request that was printed in the service logs**, similar to: ```bash theme={null} curl localhost:8080/restate/awakeables/sign_1M28aqY6ZfuwBmRnmyP/resolve --json 'true' ``` See in the UI how the workflow resumes and finishes after the approval. Invocation overview

```python human_approval_agent.py {"CODE_LOAD::https://raw.githubusercontent.com/restatedev/ai-examples/refs/heads/main/openai-agents/tour-of-agents/app/human_approval_agent.py#here"} theme={null} @durable_function_tool async def human_approval(claim: InsuranceClaim) -> str: """Ask for human approval for high-value claims.""" # Create an awakeable for human approval approval_id, approval_promise = restate_context().awakeable(type_hint=str) # Request human review await restate_context().run_typed( "Request review", request_human_review, claim=claim, awakeable_id=approval_id ) # Wait for human approval return await approval_promise ``` [Install Restate](/installation) and launch it: ```bash theme={null} restate-server ``` Get the example: ```bash theme={null} restate example python-openai-agents-tour-of-agents && cd python-openai-agents-tour-of-agents ``` Export your [OpenAI API key](https://platform.openai.com/api-keys) and run the agent: ```bash theme={null} export OPENAI_API_KEY=sk-... ``` ```bash theme={null} uv run app/human_approval_agent.py ``` Register the agents with Restate: ```bash theme={null} restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations ``` Use `curl` with `/send` to start the claim asynchronously, without waiting for the result: ```bash theme={null} curl localhost:8080/HumanClaimApprovalAgent/run/send \ --json '{"message": "Process my hospital bill of 3000USD for a broken leg."}' ``` You can restart the service to see how Restate continues waiting for the approval. If you wait for more than a minute, the invocation will get suspended. Invocation overview

```python human_approval_agent.py {"CODE_LOAD::https://raw.githubusercontent.com/restatedev/ai-examples/refs/heads/main/google-adk/tour-of-agents/app/human_approval_agent.py#here"} theme={null} async def human_approval(claim: InsuranceClaim) -> str: """Ask for human approval for high-value claims.""" # Create an awakeable for human approval approval_id, approval_promise = restate_context().awakeable(type_hint=str) # Request human review await restate_context().run_typed( "Request review", request_review, claim=claim, awakeable_id=approval_id, ) # Wait for human approval return await approval_promise ``` [Install Restate](/installation) and launch it: ```bash theme={null} restate-server ``` Get the example: ```bash theme={null} restate example python-google-adk-tour-of-agents && cd python-google-adk-tour-of-agents ``` Export your [Google API key](https://aistudio.google.com/app/apikey) and run the agent: ```bash theme={null} export GOOGLE_API_KEY=your-api-key ``` ```bash theme={null} uv run app/human_approval_agent.py ``` Register the agents with Restate: ```bash theme={null} restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations ``` Use `curl` with `/send` to start the claim asynchronously, without waiting for the result: ```bash theme={null} curl localhost:8080/HumanClaimApprovalAgent/user-123/run/send \ --json '{"message": "Process my hospital bill of 3000USD for a broken leg.", "session_id": "session-123"}' ``` You can restart the service to see how Restate continues waiting for the approval. If you wait for more than a minute, the invocation will get suspended. Invocation overview

```python human_approval_agent.py {"CODE_LOAD::https://raw.githubusercontent.com/restatedev/ai-examples/refs/heads/main/pydantic-ai/tour-of-agents/app/human_approval_agent.py#here"} theme={null} @agent.tool async def human_approval(_run_ctx: RunContext[None], claim: InsuranceClaim) -> str: """Ask for human approval for high-value claims.""" # Create an awakeable for human approval approval_id, approval_promise = restate_context().awakeable(type_hint=str) # Request human review await restate_context().run_typed( "Request review", request_human_review, claim=claim, awakeable_id=approval_id ) # Wait for human approval return await approval_promise ``` [Install Restate](/installation) and launch it: ```bash theme={null} restate-server ``` Get the example: ```bash theme={null} restate example python-pydantic-ai-tour-of-agents && cd python-pydantic-ai-tour-of-agents ``` Export your [OpenAI API key](https://platform.openai.com/api-keys) and run the agent: ```bash theme={null} export OPENAI_API_KEY=sk-... ``` ```bash theme={null} uv run app/human_approval_agent.py ``` Register the agents with Restate: ```bash theme={null} restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations ``` Use `curl` with `/send` to start the claim asynchronously, without waiting for the result: ```bash theme={null} curl localhost:8080/HumanClaimApprovalAgent/run/send \ --json '{"message": "Process my hospital bill of 3000USD for a broken leg."}' ``` You can restart the service to see how Restate continues waiting for the approval. If you wait for more than a minute, the invocation will get suspended. Invocation overview

```typescript human-approval-agent.ts {"CODE_LOAD::https://raw.githubusercontent.com/restatedev/ai-examples/refs/heads/main/typescript-restate-only/tour-of-agents/src/human-approval-agent.ts#here"} theme={null} async function run(ctx: Context, { message }: { message: string }) { const prompt = "You are an insurance claim evaluation agent. Use these rules: " + "* if the amount is more than 1000, ask for human approval, " + "* if the amount is less than 1000, decide by yourself. " + `Evaluate this claim: ${message}`; const { text, toolCalls } = await ctx.run( "LLM call", // Use your preferred LLM SDK here async () => llmCall(prompt, tools), { maxRetryAttempts: 3 }, ); if (toolCalls?.[0]?.toolName === "humanApproval") { // Create a recoverable approval promise const approval = ctx.awakeable(); await ctx.run("request-review", () => requestClaimReview(message, approval.id), ); // Suspend until reviewer resolves the approval // Check the service logs to see how to resolve it over HTTP, e.g.: // curl http://localhost:8080/restate/awakeables/sign_.../resolve --json 'true' return approval.promise; } return text; } ``` [Install Restate](/installation) and launch it: ```bash theme={null} restate-server ``` Get the example: ```bash theme={null} restate example typescript-restate-tour-of-agents && cd typescript-restate-tour-of-agents npm install ``` Export your API key: ```bash theme={null} export OPENAI_API_KEY=sk-... ``` ```bash theme={null} npx tsx ./src/human-approval-agent.ts ``` Register the services with Restate: ```bash theme={null} restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations ``` Use `curl` with `/send` to start the moderation asynchronously: ```bash theme={null} curl localhost:8080/HumanClaimApprovalAgent/run/send \ --json '{"message": "Process my hospital bill of 3000USD for a broken leg."}' ``` If you wait for more than a minute, the invocation will get suspended. Simulate approving by executing the **curl request that was printed in the service logs**, similar to: ```bash theme={null} curl localhost:8080/restate/awakeables/sign_1M28aqY6ZfuwBmRnmyP/resolve --json '"approved"' ``` See in the UI how the workflow resumes and finishes after the approval. ```python human_approval_agent.py {"CODE_LOAD::https://raw.githubusercontent.com/restatedev/ai-examples/refs/heads/main/python-restate-only/tour-of-agents/app/human_approval_agent.py#here"} theme={null} # TOOL IMPLEMENTATION async def request_human_approval(ctx: restate.Context, claim: InsuranceClaim) -> str: # Create a recoverable approval promise approval_id, approval_promise = ctx.awakeable(type_hint=str) await ctx.run_typed( "Request review", request_review, claim=claim, approval_id=approval_id ) # Suspend until human resolves the approval # Check the service logs to see how to resolve it over HTTP, e.g.: # curl http://localhost:8080/restate/awakeables/sign_.../resolve --json '"approved"' return await approval_promise # AGENT SERVICE claim_approval_agent = restate.Service("HumanClaimApprovalAgent") @claim_approval_agent.handler() async def run(ctx: restate.Context, req: ClaimPrompt) -> str | None: """Evaluate an insurance claim with optional human approval for high-value claims.""" # LLM evaluates the claim and decides if human approval is needed result = await ctx.run_typed( "Evaluate claim", llm_call, # Use your preferred LLM SDK here RunOptions(max_attempts=3), messages=f"""You are an insurance claim evaluation agent. Use these rules: - if the amount is more than 1000, ask for human approval using tools; - if the amount is less than 1000, decide by yourself. Claim: {req.message}""", tools=[ tool( "request_human_approval", "Ask for human approval for high-value claims", InsuranceClaim.model_json_schema(), ) ], ) # If the LLM requests human approval, suspend until a human resolves it if ( result.tool_calls and result.tool_calls[0].function.name == "request_human_approval" ): claim = InsuranceClaim.model_validate_json( result.tool_calls[0].function.arguments ) return await request_human_approval(ctx, claim) return result.content ``` [Install Restate](/installation) and launch it: ```bash theme={null} restate-server ``` Get the example: ```bash theme={null} restate example python-restate-tour-of-agents && cd python-restate-tour-of-agents ``` Export your API key: ```bash theme={null} export OPENAI_API_KEY=sk-... ``` ```bash theme={null} uv run app/human_approval_agent.py ``` Register the services with Restate: ```bash theme={null} restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations ``` Use `curl` with `/send` to start the claim asynchronously, without waiting for the result: ```bash theme={null} curl localhost:8080/HumanClaimApprovalAgent/run/send \ --json '{"message": "Process my hospital bill of 3000USD for a broken leg."}' ``` If you wait for more than a minute, the invocation will get suspended. Simulate approving by executing the **curl request that was printed in the service logs**, similar to: ```bash theme={null} curl localhost:8080/restate/awakeables/sign_1M28aqY6ZfuwBmRnmyP/resolve --json '"approved"' ``` See in the UI how the workflow resumes and finishes after the approval. ## Why this matters for agents * **No idle resources**: The agent suspends while waiting. On serverless infrastructure, you pay nothing during the wait. * **Survives restarts**: Even if the process or infrastructure changes, the agent resumes when the approval arrives. * **Composable**: Combine with tool calls, multi-step workflows, and other patterns. The approval is just another durable step.

## Adding timeouts Add a timeout to prevent approval steps from hanging indefinitely. Restate persists both the timer and the approval promise, so if the service crashes or is restarted, it will continue waiting with the correct remaining time. ```typescript human-approval-agent-with-timeout.ts {"CODE_LOAD::https://raw.githubusercontent.com/restatedev/ai-examples/refs/heads/main/vercel-ai/tour-of-agents/src/human-approval-agent-with-timeout.ts#here"} theme={null} const approval = ctx.awakeable(); await ctx.run("request-review", () => requestHumanReview(claim, approval.id), ); try { // At most 3 hours, to reach our SLA const approved = await approval.promise.orTimeout({ hours: 3 }); return { approved }; } catch (e) { if (e instanceof TimeoutError) { return { approved: false, reason: "Approval timed out - Evaluate with AI", }; } throw e; } ``` Start the timeout agent (stop any previously running agent first): ```bash theme={null} npx tsx ./src/human-approval-agent-with-timeout.ts ``` Register the agents with Restate: ```bash theme={null} restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations ``` Send a request to the service: ```bash theme={null} curl localhost:8080/HumanClaimApprovalWithTimeoutsAgent/run/send \ --json '{"prompt": "Process my hospital bill of 3000USD for a broken leg."}' ``` Restart the service and check in the UI how the process will block for the remaining time without starting over. You can also lower the timeout to a few seconds to see how the timeout path is taken. ```python human_approval_agent_with_timeout.py {"CODE_LOAD::https://raw.githubusercontent.com/restatedev/ai-examples/refs/heads/main/openai-agents/tour-of-agents/app/human_approval_agent_with_timeout.py#here"} theme={null} @durable_function_tool async def human_approval(claim: InsuranceClaim) -> str: """Ask for human approval for high-value claims.""" # Create an awakeable for human approval approval_id, approval_promise = restate_context().awakeable(type_hint=bool) # Request human review await restate_context().run_typed( "Request review", request_human_review, claim=claim, awakeable_id=approval_id ) # Wait for human approval for at most 3 hours to reach our SLA match await restate.select( approval=approval_promise, timeout=restate_context().sleep(timedelta(hours=3)), ): case ["approval", approved]: return "Approved" if approved else "Rejected" case _: return "Approval timed out - Evaluate with AI" ``` Start the timeout agent (stop any previously running agent first): ```bash theme={null} uv run app/human_approval_agent_with_timeout.py ``` Register the agents with Restate: ```bash theme={null} restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations ``` Send a request to the service: ```bash theme={null} curl localhost:8080/HumanClaimApprovalWithTimeoutsAgent/run/send \ --json '{"message": "Process my hospital bill of 3000USD for a broken leg."}' ``` Restart the service and check in the UI how the process will block for the remaining time without starting over. You can also lower the timeout to a few seconds to see how the timeout path is taken. ```python human_approval_agent_with_timeout.py {"CODE_LOAD::https://raw.githubusercontent.com/restatedev/ai-examples/refs/heads/main/google-adk/tour-of-agents/app/human_approval_agent_with_timeout.py#here"} theme={null} async def human_approval(claim: InsuranceClaim) -> str: """Ask for human approval for high-value claims.""" # Create an awakeable for human approval approval_id, approval_promise = restate_context().awakeable(type_hint=str) # Request human review await restate_context().run_typed( "Request review", request_review, claim=claim, awakeable_id=approval_id, ) # Wait for human approval for at most 3 hours to reach our SLA match await restate.select( approval=approval_promise, timeout=restate_context().sleep(timedelta(hours=3)), ): case ["approval", approved]: return "Approved" if approved else "Rejected" case _: return "Approval timed out - Evaluate with AI" ``` Start the timeout agent (stop any previously running agent first): ```bash theme={null} uv run app/human_approval_agent_with_timeout.py ``` Register the agents with Restate: ```bash theme={null} restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations ``` Send a request to the service: ```bash theme={null} curl localhost:8080/HumanClaimApprovalWithTimeoutsAgent/user-123/run/send \ --json '{"message": "Process my hospital bill of 3000USD for a broken leg.", "session_id": "session-123"}' ``` Restart the service and check in the UI how the process will block for the remaining time without starting over. You can also lower the timeout to a few seconds to see how the timeout path is taken. Use `restate.select` to race the approval promise against a sleep timer: ```python human_approval_agent_with_timeout.py {"CODE_LOAD::https://raw.githubusercontent.com/restatedev/ai-examples/refs/heads/main/pydantic-ai/tour-of-agents/app/human_approval_agent_with_timeout.py#here"} theme={null} @agent.tool async def human_approval(_run_ctx: RunContext[None], claim: InsuranceClaim) -> str: """Ask for human approval for high-value claims.""" # Create an awakeable for human approval approval_id, approval_promise = restate_context().awakeable(type_hint=bool) # Request human review await restate_context().run_typed( "Request review", request_human_review, claim=claim, awakeable_id=approval_id ) # Wait for human approval for at most 3 hours to reach our SLA match await restate.select( approval=approval_promise, timeout=restate_context().sleep(timedelta(hours=3)), ): case ["approval", approved]: return "Approved" if approved else "Rejected" case _: return "Approval timed out - Evaluate with AI" ``` Start the timeout agent (stop any previously running agent first): ```bash theme={null} uv run app/human_approval_agent_with_timeout.py ``` Register the agents with Restate: ```bash theme={null} restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations ``` Send a request to the service: ```bash theme={null} curl localhost:8080/HumanClaimApprovalWithTimeoutsAgent/run/send \ --json '{"message": "Process my hospital bill of 3000USD for a broken leg."}' ``` Restart the service and check in the UI how the process will block for the remaining time without starting over. You can also lower the timeout to a few seconds to see how the timeout path is taken. Use `orTimeout` on the awakeable promise: ```typescript theme={null} const approval = ctx.awakeable(); await ctx.run("Ask review", () => notifyModerator(message, approval.id)); try { // At most 3 hours, to reach our SLA const result = await approval.promise.orTimeout({ hours: 3 }); return result; } catch (e) { if (e instanceof TimeoutError) { return "Approval timed out - Evaluate with AI"; } throw e; } ``` Start the timeout agent (stop any previously running agent first): ```bash theme={null} npx tsx ./src/human-approval-agent-with-timeout.ts ``` Register the agents with Restate: ```bash theme={null} restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations ``` Send a request to the service: ```bash theme={null} curl localhost:8080/HumanClaimApprovalWithTimeoutsAgent/run/send \ --json '{"prompt": "Process my hospital bill of 3000USD for a broken leg."}' ``` Restart the service and check in the UI how the process will block for the remaining time without starting over. You can also lower the timeout to a few seconds to see how the timeout path is taken. ```python human_approval_agent_with_timeout.py {"CODE_LOAD::https://raw.githubusercontent.com/restatedev/ai-examples/refs/heads/main/python-restate-only/tour-of-agents/app/human_approval_agent_with_timeout.py#here"} theme={null} async def request_human_approval(ctx: restate.Context, claim: InsuranceClaim) -> str: # Create a recoverable approval promise approval_id, approval_promise = ctx.awakeable(type_hint=str) await ctx.run_typed( "Request review", request_review, claim=claim, approval_id=approval_id ) # Suspend until human resolves the approval or until the timeout hits # Check the service logs to see how to resolve it over HTTP, e.g.: # curl http://localhost:8080/restate/awakeables/sign_.../resolve --json '"approved"' match await restate.select( approval=approval_promise, timeout=ctx.sleep(timedelta(hours=3)), ): case ["approval", approved]: return approved case _: return "Approval timed out - Evaluate with AI" ``` Start the timeout agent (stop any previously running agent first): ```bash theme={null} uv run app/human_approval_agent_with_timeout.py ``` Register the services with Restate: ```bash theme={null} restate deployments register http://localhost:9080 --force --yes # dev only: overrides previous registrations ``` Send a request to the service: ```bash theme={null} curl localhost:8080/HumanClaimApprovalWithTimeoutsAgent/run/send \ --json '{"message": "Process my hospital bill of 3000USD for a broken leg."}' ``` Restart the service and check in the UI how the process will block for the remaining time without starting over. You can also lower the timeout to a few seconds to see how the timeout path is taken.