Durable execution where agents, services, and humans coordinate as equals.

Your agent receives intents via stream (SSE), poll, HTTP webhook, inbox, or internal runtime — AXME handles routing, delivery, retries, and lifecycle. The workflow is defined in a ScenarioBundle JSON.

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

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

for await (const delivery of client.listen("agent://acme/prod/compliance-checker")) {
  const intent = await client.getIntent(delivery.intent_id);
  const result = checkCompliance(intent.payload);
  await client.resumeIntent(delivery.intent_id, {
    passed: result.passed,
    reason: result.reason,
  });
}

from axme import AxmeClient, AxmeClientConfig

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

for delivery in client.listen("agent://acme/prod/compliance-checker"):
    intent = client.get_intent(delivery["intent_id"])
    result = check_compliance(intent["payload"])
    client.resume_intent(delivery["intent_id"], {
        "passed": result["passed"],
        "reason": result["reason"],
    })

import "github.com/AxmeAI/axme-sdk-go/axme"

client, _ := axme.NewClient(axme.ClientConfig{
    APIKey:  os.Getenv("AXME_API_KEY"),
    BaseURL: os.Getenv("AXME_BASE_URL"),
})

ch, _ := client.Listen(ctx, "agent://acme/prod/compliance-checker", axme.ListenOptions{})
for delivery := range ch {
    intent, _ := client.GetIntent(ctx, delivery.IntentID, axme.RequestOptions{})
    result := checkCompliance(intent)
    client.ResumeIntent(ctx, delivery.IntentID, map[string]any{
        "passed": result.Passed, "reason": result.Reason,
    }, axme.RequestOptions{})
}

import dev.axme.sdk.*;

var client = new AxmeClient(new AxmeClientConfig(
    System.getenv("AXME_BASE_URL"), System.getenv("AXME_API_KEY")
));

// Poll SSE stream for deliveries, process each intent
for (var delivery : SseHelper.pollAgentStream(BASE, KEY, ADDR, since, 15)) {
    var id = SseHelper.str(delivery, "intent_id");
    var intent = client.getIntent(id, RequestOptions.none());
    var result = checkCompliance(SseHelper.effectivePayload(intent));
    client.resumeIntent(id,
        Map.of("passed", result.passed, "reason", result.reason),
        RequestOptions.none());
}

using Axme.Sdk;

var client = new AxmeClient(new AxmeClientConfig {
    ApiKey = Environment.GetEnvironmentVariable("AXME_API_KEY")!,
    BaseUrl = Environment.GetEnvironmentVariable("AXME_BASE_URL")
});

// Poll SSE stream for deliveries, process each intent
foreach (var d in await SseHelper.PollAgentStreamAsync(baseUrl, apiKey, addr, since)) {
    var id = SseHelper.Str(d, "intent_id");
    var intent = await client.GetIntentAsync(id);
    var result = CheckCompliance(SseHelper.EffectivePayload(intent));
    await client.ResumeIntentAsync(id, new JsonObject {
        ["passed"] = result.Passed, ["reason"] = result.Reason
    });
}

{
  "scenario_id": "compliance.check.v1",
  "agents": [
    { "role": "checker", "address": "compliance-checker", "delivery_mode": "stream" }
  ],
  "workflow": {
    "entry_step": "check",
    "steps": [{ "step_id": "check", "assigned_to": "checker" }]
  }
}

axme scenarios apply scenario.json --watch

AI agents need production infrastructure that traditional tools don't provide: approvals that wait hours, retries across agent boundaries, and audit trails for compliance. AXME adds these to any agent framework in minutes.

• Long-running agent workflows with durable state
• Cross-agent coordination and multi-step pipelines
• Deterministic execution for LLM-driven processes
• Every task type delivers via email magic link → web form → audit trail

• Approval. Yes/no gate for deploys, budgets, or agent actions. CLI (axme tasks approve) or email magic link.
• Form. Structured input with required fields — agent collects parameters, config values, or onboarding data.
• Review. Approve, request changes, or reject with comments — code review, AI output review, document sign-off.
• Override. Bypass a policy gate with mandatory justification. Audit-logged for compliance.
• Confirmation. Confirm a real-world action was completed — deployment verified, payment sent, shipment dispatched.
• Assignment. Route work to a person or team with structured fields — task delegation with accountability.
• Clarification. Request missing context — comment required before workflow can proceed.
• Manual action. Complete a physical task and attach evidence — warehouse pick, hardware swap, site inspection.

MCP defines what your AI assistant can do: tools, resources, and context. AXME defines how long it takes and what happens next: durable lifecycle, human approvals, retries, and cross-agent coordination.

• MCP tool call triggers an AXME intent. The agent's action becomes a tracked, durable operation — not a fire-and-forget call.
• Waiting states survive context windows. Agent can disconnect and resume hours later via since=<last_seq> — no state lost.
• Human approval in the loop. MCP call pauses, waits for a human response via CLI, email, or form, then resumes automatically.
• Works with Claude, ChatGPT, Gemini. Any MCP-enabled assistant connects via the same JSON-RPC 2.0 endpoint and bearer token auth.

• Webhooks fail silently or arrive twice
• Retry logic gets scattered across services
• Polling loops add load and hide failures
• Human approvals break automation chains
• No shared execution state exists across time
• Temporal requires determinism constraints and a dedicated platform team
• Workflow engines add complexity when you need a simple approval gate

AXP is the Intent Protocol: submit an intent, observe a durable lifecycle, and receive a terminal outcome later.

• Not RPC. Create returns intent_id and state, not a synchronous result.
• Ordered lifecycle events. Per-intent monotonic sequencing enables replay and recovery.
• Explicit waiting states. Human, tool, agent, and time waits are modeled directly in the lifecycle.
• Handler transfer. Execution ownership can move without breaking continuity.

  Initiator              AXME Cloud               Handler
  (service / agent)      (Gateway + Registry)     (agent / human / internal)
      │                       │                         │
      │── submit intent ─────>│                         │
      │                       │── resolve address       │
      │                       │   (Agent Registry)      │
      │                       │                         │
      │                       │── deliver via binding ─>│
      │                       │                         │
      │                       │   ┌─────────────────┐   │
      │                       │   │ stream  SSE push│   │
      │                       │   │ poll    pull    │   │
      │                       │   │ http    webhook │   │
      │                       │   │ inbox   reply_to│   │
      │                       │   │ internal  local │   │
      │                       │   └─────────────────┘   │
      │                       │                         │
      │                       │◄── completion event ────│
      │◄── lifecycle update ──│                         │
      │                       │                         │
      └ durable lifecycle across time (seconds to days)─│

Five delivery bindings determine how intents reach their handler. Stream and poll are agent-initiated connections. HTTP is gateway-initiated webhook push with HMAC signature verification and retries. Inbox delivers results to the initiator's reply_to address. Internal handles orchestration within agent-core — no external delivery needed.

• At-least-once delivery with replay support for recovery
• Idempotency support for retry-safe writes
• Five delivery bindings: stream (SSE push), poll (agent-initiated), http (webhook with retry and HMAC signature), inbox (reply_to delivery), and internal (agent-core orchestration)
• Initiators can disconnect and resume without losing lifecycle progress

• Cross-boundary routing. Route intents across services and organizations via The Registry.
• Protocol, not framework. Integrate via SDKs or the versioned Public API without adopting a workflow runtime.
• Identity is first-class. Global addresses and deterministic route lookup happen before execution.
• Initiators can disconnect. Completion arrives via stream, polling, or reply_to inbox.

• Transport-agnostic protocol with deterministic route resolution
• Two-layer auth: x-api-key for platform identity + Authorization: Bearer <actor_token> for actor context
• Passwordless login via email OTP — no passwords, no browser OAuth required
• Two-token session model: 15-min JWT access token + 30-day rotating refresh token; proactive renewal before expiry
• Credentials stored in OS keychain or 0600 file — never in plaintext config
• Owner-scoped authorization with fail-closed JWT/JWKS validation and auditable access events

Security architecture and controls: Security overview.

Three approaches to adding a human approval gate to an async workflow:

# Webhook endpoint + email sender + polling loop + timeout
# + retry logic + idempotency key + state table + error handling
# + cleanup cron + audit logging ...
# Scattered across 4-6 files, breaks silently.

# Workflow definition + activity + worker + signal handler
# + determinism constraints + Temporal server to operate
# Works, but requires a platform team to run and maintain.

from axme import AxmeClient, AxmeClientConfig

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

intent = client.send_intent(
    scenario_id="approval.v1",
    intent_type="intent.approval.v1",
    payload={"change": "deploy v2.1 to production"},
)
# Intent is now durable. Reminder in 5 min, timeout in 8 hours.
# Human approves via CLI, email link, or form.
# No webhook, no polling, no state table, no cron.

Start with a runnable demo, then go deeper into docs, security, protocol details, or SDKs.

MCP is a supported integration path for assistant tools. AXP is the continuation and coordination layer, not a replacement for MCP.

CLI-first alpha access. No sales calls. No contracts.

Install AXME CLI, run axme login, and your workspace is provisioned automatically.

Open the CLI onboarding page for the exact install and first-run commands.