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

#temporal #python #workflow #durableexecution

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:

A notification service - Temporal doesn't notify humans. You build email/Slack integration.
A UI or API for the human to send the signal back to Temporal.
Reminder logic - if the human doesn't respond in 30 minutes, send another notification. Temporal doesn't do this.
Escalation - if person A doesn't respond in 2 hours, notify person B. You build this.
A Temporal cluster - deploy, operate, monitor. Or pay for Temporal Cloud.
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: