Inngest Alternative - Python

AXME is a coordination infrastructure for durable execution of long-running intents across distributed systems.

Inngest gives you event-driven functions with built-in queues. But it only supports machine-to-machine steps. Need a human approval in the middle? Need to fan out to multiple agents? Need delivery mode control? Build it yourself. AXME handles all of this at the protocol level.

Alpha - Built with AXME (AXP Intent Protocol). cloud.axme.ai - hello@axme.ai

---

The Problem

You need durable job processing with delivery guarantees. Your options:

Inngest (event schemas + function config + queue infra)

import inngest

client = inngest.Inngest(app_id="my-app")

@client.create_function(
    fn_id="process-invoice",
    trigger=inngest.TriggerEvent(event="jobs/invoice.generate"),
    retries=3,
)
async def process_invoice(ctx: inngest.Context, step: inngest.Step):
    # Step 1: Validate
    validation = await step.run("validate-params", validate_job_params)

    # Step 2: Generate
    invoice = await step.run("generate-invoice", generate_invoice)

    # Step 3: Upload
    url = await step.run("upload-artifact", upload_to_storage)

    # Want human approval here? Build it yourself.
    # Want to fan out to multiple agents? Not supported.
    # Want the receiver to choose delivery mode? Not supported.

    return {"invoice_url": url, "pages": invoice["pages"]}

Plus: Event schema definitions, function registration, Inngest Dev Server or Cloud, queue configuration.

AXME (4 lines, managed service)

intent_id = client.send_intent({
    "intent_type": "intent.jobs.process.v1",
    "to_agent": "agent://myorg/production/job-processor",
    "payload": {"job_type": "invoice_generation", "customer": "enterprise-corp"},
})
result = client.wait_for(intent_id)

---

Quick Start

Python

pip install axme
export AXME_API_KEY="your-key"   # Get one: axme login

from axme import AxmeClient, AxmeClientConfig
import os

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

intent_id = client.send_intent({
    "intent_type": "intent.jobs.process.v1",
    "to_agent": "agent://myorg/production/job-processor",
    "payload": {
        "job_id": "JOB-2026-1234",
        "job_type": "invoice_generation",
        "customer": "enterprise-corp",
        "params": {"period": "2026-Q1", "format": "pdf"},
    },
})

print(f"Submitted: {intent_id}")
result = client.wait_for(intent_id)
print(f"Done: {result['status']}")

TypeScript

npm install @axme/axme

import { AxmeClient } from "@axme/axme";

const client = new AxmeClient({ apiKey: process.env.AXME_API_KEY! });

const intentId = await client.sendIntent({
  intentType: "intent.jobs.process.v1",
  toAgent: "agent://myorg/production/job-processor",
  payload: {
    jobId: "JOB-2026-1234",
    jobType: "invoice_generation",
    customer: "enterprise-corp",
    params: { period: "2026-Q1", format: "pdf" },
  },
});

console.log(`Submitted: ${intentId}`);
const result = await client.waitFor(intentId);
console.log(`Done: ${result.status}`);

---

More Languages

Language	Directory	Install
Python	python/	pip install axme
TypeScript	typescript/	npm install @axme/axme

---

Inngest vs AXME

	Inngest	AXME
Model	Event-driven functions with steps	Intent lifecycle with durable delivery
Human tasks	Not supported (machine-only)	Built-in (8 task types)
Delivery modes	Push only (webhook)	5 modes (SSE, poll, push, inbox, internal)
Multi-agent	Not supported	First-class (agents, services, humans)
Retries	Function-level retries	Protocol-level delivery guarantees
Infrastructure	Inngest Dev Server or Cloud	AXME Cloud (managed)
Approval gates	Build it yourself	Built-in with reminders and escalation
Observability	Dashboard	Real-time SSE lifecycle stream
Best for	Background jobs, scheduled tasks	Agent-era workflows: services + agents + humans

Inngest is good for simple background job processing. AXME is better when you need human-in-the-loop, multi-agent coordination, or protocol-level delivery guarantees.

---

How It Works

+-----------+  send_intent()   +----------------+   deliver    +-----------+
|           | ---------------> |                | -----------> |           |
|  Client   |                  |   AXME Cloud   |              |    Job    |
|           | <- wait_for() -- |   (platform)   | <- resume()  | Processor |
|           |                  |                |  with result |  (agent)  |
+-----------+                  |   retries,     |              |           |
                               |   timeouts,    |              | generates |
                               |   delivery     |              |  invoice  |
                               +----------------+              +-----------+

1. Client submits a job intent with parameters and customer details
2. Platform delivers it to the job processor agent
3. Agent processes the job (validate, generate, upload) and resumes with result
4. Client observes lifecycle events in real time (SSE stream)
5. Platform handles retries, timeouts, and delivery guarantees

---

Run the Full Example

Prerequisites

# Install CLI (one-time)
curl -fsSL https://raw.githubusercontent.com/AxmeAI/axme-cli/main/install.sh | sh
# Open a new terminal, or run the "source" command shown by the installer

# Log in
axme login

# Install Python SDK
pip install axme

Terminal 1 - submit the scenario

axme scenarios apply scenario.json
# Note the intent_id in the output

Terminal 2 - start the agent

Get the agent key after scenario apply:

# macOS
cat ~/Library/Application\ Support/axme/scenario-agents.json | grep -A2 inngest-alt-processor-demo

# Linux
cat ~/.config/axme/scenario-agents.json | grep -A2 inngest-alt-processor-demo

Run in your language of choice:

# Python
AXME_API_KEY=<agent-key> python agent.py

# TypeScript (requires Node 20+)
cd typescript && npm install
AXME_API_KEY=<agent-key> npx tsx agent.ts

Verify

axme intents get <intent_id>
# lifecycle_status: COMPLETED

---

Related

• AXME - project overview
• AXP Spec - open Intent Protocol specification
• AXME Examples - 20+ runnable examples across 5 languages
• AXME CLI - manage intents, agents, scenarios from the terminal

---

Built with AXME (AXP Intent Protocol).