What Temporal Can't Do: Human Approval Mid-Workflow

Temporal is excellent at durable execution. I'm not here to argue otherwise.

But try adding a human approval step to a Temporal workflow. Something like: agent validates a database migration, then an SRE needs to approve before it runs.

What This Looks Like in Temporal

@workflow.defn
class ApprovalWorkflow:
    def __init__(self):
        self.approved = None

    @workflow.run
    async def run(self, change):
        result = await workflow.execute_activity(
            validate_change, change,
            start_to_close_timeout=timedelta(minutes=5)
        )

        # Wait for human signal
        await workflow.wait_condition(
            lambda: self.approved is not None
        )

        if not self.approved:
            return {"status": "rejected"}

        return await workflow.execute_activity(
            apply_change, change,
            start_to_close_timeout=timedelta(minutes=10)
        )

    @workflow.signal
    async def approval_signal(self, approved: bool):
        self.approved = approved

This is the workflow. Now you need:

1. A notification service - Temporal doesn't notify humans. You build email/Slack integration.
2. A UI or API for the human to send the signal back to Temporal.
3. Reminder logic - if the human doesn't respond in 30 minutes, send another notification. Temporal doesn't do this.
4. Escalation - if person A doesn't respond in 2 hours, notify person B. You build this.
5. A Temporal cluster - deploy, operate, monitor. Or pay for Temporal Cloud.
6. Determinism constraints - no random(), no datetime.now(), no network calls in workflow code. Every developer on the team needs to learn this.

The workflow is 20 lines. The infrastructure around it is 200.

What This Looks Like Without Temporal

from axme import AxmeClient, AxmeClientConfig

client = AxmeClient(AxmeClientConfig(api_key=os.environ["AXME_API_KEY"]))

intent_id = client.send_intent({
    "intent_type": "intent.infra.change_approval.v1",
    "to_agent": "agent://myorg/production/infra-validator",
    "payload": {
        "change_type": "database_migration",
        "target": "prod-postgres-main",
        "migration": "add_index_users_email",
    },
})
result = client.wait_for(intent_id)

Four lines. The platform handles:

• Durable execution (state in PostgreSQL)
• Human approval gate (built-in, not bolted on)
• Reminders (configurable: 5 min, 30 min, custom)
• Escalation (person A -> person B -> team)
• Timeout (graceful, with fallback action)
• Notification (CLI, email, Slack)
• Audit trail (who approved, when, with what context)
• No determinism constraints
• No cluster to operate

Side-by-Side

	Temporal	AXME
Lines of code	80+	4
Human approval	Build it (signals + UI + notifications)	Built-in
Reminders	Build it	Built-in
Determinism constraints	Required	None
Infrastructure	Cluster (self-hosted or Cloud)	Managed API
Setup time	Days	Minutes
Escalation	Build it	Built-in

When to Use Which

Use Temporal when:

• You have complex, long-running workflows with many branches and compensation logic
• You have a platform team that can operate a Temporal cluster
• Determinism constraints are acceptable for your team
• Human approval is a small part of a larger workflow

Use AXME when:

• You need human approval gates in otherwise simple workflows
• You don't want to operate infrastructure
• Your team doesn't want to learn determinism constraints
• You need built-in reminders, escalation, and structured approval types
• You need it working in minutes, not days

They're not competing for the same use cases. Temporal is a workflow engine. AXME is a coordination layer with human approval built in.

Try It

Working example - agent validates an infrastructure change, workflow pauses for SRE approval, completes after human decision:

github.com/AxmeAI/durable-execution-with-human-approval

Python, TypeScript, and Go implementations included.

Built with AXME - durable execution with human approval built in. Alpha - feedback welcome.