# AX Check: temporal.io
Checked 2026-09-28.

Temporal's quickstart and pricing are both usable right away.
21 of 23 checklist items passed: install commands, code samples, and pricing tables are all readable without login or extra clicks.

## Onboarding needs a login

## Coding sessions
All three independent sessions (DeepSeek V4.1 Flash, Kimi K3, Qwen 3.8 Max) completed and reported concrete Temporal Cloud pricing, citing per-million-Actions rates, storage costs, and business tier fees, each noting its own sourcing assumptions.

### DeepSeek V4.1 Flash
[View public run](https://agents.withgauge.com/p/runs/7d8c29f0-ff1b-47a2-9537-7380f4e940b9) · [Read transcript](https://www.ax-check.com/temporal.io/sessions/deepseek.json)
Final output gives concrete pricing ($50/$25 per million Actions, $150 free credits, $500/mo business add-on) sourced from live-scraped pricing pages (seq 11-21) with plan/tier assumptions (self-serve vs. commit, Actions-based workload) stated.
#### End-to-end onboarding
- **Onboarding needs a login**: Agent searched the sandbox for Temporal CLI, SDK, and TEMPORAL_* environment variables and found none. It never obtained Temporal Cloud credentials (namespace, API key) and never executed any authenticated operation against the hosted product. It only wrote unrun example code and fetched public pricing/docs pages over HTTP.
  Event 6:

  ```text
  === env (temporal-related) ===
  no TEMPORAL env vars
  
  ```
  Event 38:

  ```text
  No hosted credentials. Temporal Cloud is reachable, but there's no `TEMPORAL_ADDRESS`, `TEMPORAL_NAMESPACE`, or `TEMPORAL_API_KEY` in this environment, and I can't create a Cloud account (email/payment).
  ```
  Event 38:

  ```text
  It is not runned. I wrote it but did not install deps or execute it.
  ```

#### Hallucinated URLs
None identified in this transcript.

#### Blockers
- **No Temporal Cloud credentials available in sandbox**: The sandbox has no TEMPORAL_ADDRESS, TEMPORAL_NAMESPACE, or TEMPORAL_API_KEY, and the agent has no way to self-serve create a Temporal Cloud account (requires email/payment). This is a missing-credentials limitation of the test environment, not a product defect, since Temporal Cloud normally requires normal signup/login.
  Event 9:

  ```text
  Network is up, but no Temporal CLI, no SDK installed, and — importantly — no Temporal Cloud credentials (`TEMPORAL_API_KEY`, namespace, etc.).
  ```
  Event 38:

  ```text
  there's no `TEMPORAL_ADDRESS`, `TEMPORAL_NAMESPACE`, or `TEMPORAL_API_KEY` in this environment, and I can't create a Cloud account (email/payment)
  ```
- **Official quickstart requires a long-running local service or credentials**: The only credential-free path documented by Temporal is running a local dev server (temporal server start-dev) plus a long-running worker poll loop, both of which the session's instructions explicitly forbade. This is expected product behavior for a workflow orchestration engine (it needs a persistent server), colliding with the test's 'no local stacks, no long-running commands' constraint rather than being a product flaw.
  Event 13:

  ```text
  p>This command starts a local Temporal Service. It starts the Web UI, creates the default Namespace, and uses an in-memory
  ```
  Event 38:

  ```text
  The official quickstart uses `temporal server start-dev`, a long-running **local service stack**, and the worker itself is a **long-running poll loop**. You told me not to start local stacks or wait on long-running commands.
  ```

#### Suggested Changes
- **Offer a lightweight, credential-free way to run a single workflow**: Currently the only paths to a runnable example are a local long-running dev server or a Temporal Cloud account with API key/namespace. Consider a hosted sandbox/trial endpoint (no signup friction, short-lived) that lets a new developer execute one workflow via SDK/API without standing up infrastructure. Validate by having a new developer run the TypeScript quickstart end-to-end using only environment variables, with no local daemon and no multi-step account creation.
  Event 38:

  ```text
  the runnable quickstart requires either a local service stack or Temporal Cloud credentials I don't have
  ```

### Kimi K3
[View public run](https://agents.withgauge.com/p/runs/ed0596bd-d7a7-4397-bf60-74e1f7f6acf1) · [Read transcript](https://www.ax-check.com/temporal.io/sessions/kimi.json)
Final output gives concrete Temporal Cloud pricing (~$25/million actions, ~$0.30/GB-month storage) while naming assumptions/caveats (self-hosted vs cloud, 'exact numbers change — verify at temporal.io/pricing', hobby-project framing).
#### End-to-end onboarding
- **Onboarding needs a login**: Agent checked the environment for Temporal credentials, found none, and did not obtain any during the session. It explicitly declined to run either the local dev server or Temporal Cloud (needs API keys/namespace it lacks), so no authenticated operation against the hosted product ever occurred. Only unexecuted scaffold code was produced.
  Event 5:

  ```text
  no temporal credentials in env
  ```
  Event 9:

  ```text
  Temporal Cloud** — the hosted product. Requires an account, namespace, and API keys/certificates, which I don't have in this environment (checked — no credentials).
  ```
  Event 25:

  ```text
  I did **not** start the dev server or run anything long-lived. The example in `/sandbox/repo/temporal-example/` is ready but unexecuted
  ```

#### Hallucinated URLs
None identified in this transcript.

#### Blockers
- **No Temporal Cloud credentials available in sandbox**: The environment had no Temporal Cloud API keys, certificates, or namespace configured, and the user's constraints ruled out starting a local dev server. This is a test-environment/credential limitation, not a product defect — Temporal's SDK is inherently a client that requires a running service (local or cloud) to execute any workflow.
  Event 5:

  ```text
  no temporal credentials in env
  ```
  Event 9:

  ```text
  The SDK alone cannot run a workflow; it's a client that talks to a Temporal service. So I can write the example code, but I can't execute it end-to-end without violating your constraints.
  ```
- **Quickstart requires a long-running local service**: The official Temporal quickstart path is `temporal server start-dev`, a long-running local service stack explicitly excluded by the session's instructions, leaving no way to execute the example without either that or cloud credentials.
  Event 9:

  ```text
  Local dev server** — the official quickstart is `temporal server start-dev`, a long-running local service stack. Excluded by your constraints.
  ```

#### Suggested Changes
- **Offer a lightweight hosted sandbox/trial namespace for Temporal Cloud**: Session friction came from having no way to obtain a Temporal Cloud namespace or API key without human account creation, and no way to execute any workflow without either that or a long-running local dev server. Providing a self-serve trial namespace with programmatically obtainable API keys (documented in the quickstart) would let an agent complete an authenticated run without a human in the loop; verify by having an agent request a namespace/key via API and successfully start a workflow against it.
  Event 9:

  ```text
  Requires an account, namespace, and API keys/certificates, which I don't have in this environment (checked — no credentials).
  ```

### Qwen 3.8 Max
[View public run](https://agents.withgauge.com/p/runs/8c9b3f45-2397-4c06-b1ee-737415974512) · [Read transcript](https://www.ax-check.com/temporal.io/sessions/qwen.json)
Final output gives concrete pricing (actions from $50/million, storage $0.042/GB-hr active vs $0.00105/GB-hr retained, support tiers) with explicit assumptions named (consumption model, $150/90-day trial credit, cost scales with state transitions not wall-clock).
#### End-to-end onboarding
- **Onboarding needs a login**: Agent never obtained real Temporal Cloud credentials. It searched the sandbox environment for TEMPORAL_NAMESPACE/TEMPORAL_API_KEY, found none, confirmed network egress to saas-api.tmprl.cloud worked, but explicitly stated account/namespace/API key creation requires a human web signup with email/SSO and billing card, which it could not perform. It wrote a demo script and verified only that it imports without error (no live namespace, no authenticated call executed).
  Event 6:

  ```text
  PI_GATEWAY_API_KEY=<redacted>
  ```
  Event 68:

  ```text
  The blocker: there are no Temporal Cloud credentials in this environment (`TEMPORAL_NAMESPACE` / `TEMPORAL_API_KEY` are unset, no mTLS certs, no `temporal` CLI). Account + namespace creation is a web signup at cloud.temporal.io with email/SSO verification and a card on file — I can't and shouldn't do that on your behalf.
  ```
  Event 68:

  ```text
  **Not verified end-to-end** — I have never seen it actually execute, because that needs a namespace. Treat it as unrun code.
  ```

#### Hallucinated URLs
None identified in this transcript.

#### Blockers
- **No Temporal Cloud account or API key available**: The sandbox has no Temporal Cloud namespace, API key, or mTLS certs, and creating them requires a human-driven web signup (email/SSO verification plus billing card) at cloud.temporal.io. This is a normal credential/login requirement, not a product defect — the agent correctly identified it could not self-provision an account and stopped short of running the example end-to-end.
  Event 68:

  ```text
  there are no Temporal Cloud credentials in this environment (`TEMPORAL_NAMESPACE` / `TEMPORAL_API_KEY` are unset, no mTLS certs, no `temporal` CLI). Account + namespace creation is a web signup at cloud.temporal.io with email/SSO verification and a card on file — I can't and shouldn't do that on your behalf.
  ```
  Event 50:

  ```text
  none set
  ```
- **SDK import path in initial code draft didn't match installed SDK version**: The agent initially wrote code importing execute_activity from temporalio.activity, which failed against the installed 1.33.0 SDK (that function actually lives on temporalio.workflow). This was an agent authoring error rather than a product blocker, and it self-corrected after inspecting the installed package's API surface.
  Event 50:

  ```text
  ImportError: cannot import name 'execute_activity' from 'temporalio.activity' (/opt/freestyle/python/lib/python3.12/site-packages/temporalio/activity.py)
  ```
  Event 62:

  ```text
  imports OK: GreetingWorkflow greet
  ```

#### Suggested Changes
- **Add a version-matched import example to the Python SDK quickstart**: The agent's first code draft imported execute_activity from temporalio.activity, which failed against the pip-installed 1.33.0 SDK since that function lives on temporalio.workflow instead. Adding or verifying a current, version-matched code snippet in the quickstart (confirming workflow.execute_activity is the documented call path) would prevent this trial-and-error. Check by pip installing temporalio fresh and confirming the quickstart's import lines match the installed package's actual API surface.
  Event 50:

  ```text
  ImportError: cannot import name 'execute_activity' from 'temporalio.activity' (/opt/freestyle/python/lib/python3.12/site-packages/temporalio/activity.py)
  ```

### Task given to each agent
Help me build a simple example using Temporal. Tell me how pricing works, and briefly tell me whether this product will be easy for you to manage. Let me know if you get blocked. If this product has no developer workflow you can act on, say so plainly and stop. Stay light: use the hosted product through its SDK or API. Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop.

No product credentials were supplied and no purchases were authorized.

## Score: B · 84/100 (provisional)
Grades come from completed site checks. Coding sessions and skipped checks do not affect the score.

### Clarity
- **Failed** — Homepage answers Markdown requests

  ```text
  Homepage returned text/html for a text/markdown request; llms.txt confirms temporal.io pages are HTML only.
  ```

- **Pass** — llms.txt provides an actionable documentation index

  ```text
  llms.txt links quickstarts, docs indexes, SDK guides, CLI reference, and pricing Markdown.
  ```

- **Pass** — llms.txt provides navigation guidance

  ```text
  llms.txt has 'Start here' and sectioned navigation with per-section indexes and .md guidance.
  ```

- **Pass** — llms.txt mentions offered API, MCP, and skills

  ```text
  llms.txt lists API reference index, MCP server, and Agent Skills with install commands.
  ```

- **Pass** — A compact guide representation exists

  ```text
  Rust quickstart served as raw Markdown at /develop/rust/quickstart.md, 1776 tokens.
  ```

- **Pass** — A focused guide is directly retrievable

  ```text
  Rust quickstart gives concrete steps: install Rust, add deps, run CLI, start Workflow.
  ```

- **Pass** — Equivalent instructions fit a token budget

  ```text
  Markdown quickstart is 1776 tokens, well under the 8000-token budget.
  ```

- **Skipped** — Product-docs links survive format changes

  ```text
  Homepage Markdown unsupported, so link preservation across formats cannot be measured.
  ```

- **Pass** — The compact guide is independently actionable

  ```text
  Rust quickstart gives concrete steps: install Rust, add deps, install CLI, run dev server, run Hello World.
  ```

- **Pass** — Install and next-step links resolve

  ```text
  Fetched quickstart, Rust quickstart, and API reference pages all returned HTTP 200.
  ```


### Onboarding
- **Pass** — Docs lead to a relevant quickstart

  ```text
  llms.txt links Quickstarts; quickstarts.md lists per-language quickstarts with concrete first steps.
  ```

- **Pass** — Installation commands are extractable

  ```text
  Rust quickstart gives extractable install commands: brew install temporal, cargo init, temporal server start-dev.
  ```

- **Pass** — Code examples are available without interaction

  ```text
  Rust quickstart shows full Activity, Workflow, and Worker code examples inline without interaction.
  ```

- **Pass** — Prerequisites and auth boundaries are explicit

  ```text
  Quickstart states Rust/Cargo prerequisites; Cloud auth via API key documented in CLI cloud references.
  ```


### Pricing
- **Pass** — Pricing is readable without interaction

  ```text
  Temporal's pricing.md renders full plan and usage tables as static Markdown, no interaction needed.
  ```

- **Pass** — Prices are stated, not gated

  ```text
  Prices stated: $0/mo Developer, $500/mo Business, $50/M Actions, storage rates.
  ```

- **Pass** — Pricing units and limits are explicit

  ```text
  Units explicit: per-million Actions, GBh storage, APS/TRU capacity, 10% support fee.
  ```

- **Pass** — Agents identify pricing and its assumptions

  ```text
  3 of 3 sessions were judged on pricing; 0 fell short. DeepSeek V4.1 Flash: Final output gives concrete pricing ($50/$25 per million Actions, $150 free credits, $500/mo business add-on) sourced from live-scraped pricing pages (seq 11-21) with plan/tier assumptions (self-serve vs. commit, Actions-based workload) stated. Kimi K3: Final output gives concrete Temporal Cloud pricing (~$25/million actions, ~$0.30/GB-month storage) while naming assumptions/caveats (self-hosted vs cloud, 'exact numbers change — verify at temporal.io/pricing', hobby-project framing). Qwen 3.8 Max: Final output gives concrete pricing (actions from $50/million, storage $0.042/GB-hr active vs $0.00105/GB-hr retained, support tiers) with explicit assumptions named (consumption model, $150/90-day trial credit, cost scales with state transitions not wall-clock). This behavioural item does not affect the fast grade.
  ```


### Activation
- **Pass** — An API reference or OpenAPI spec is reachable

  ```text
  API reference index links all SDK API references plus the gRPC Server Frontend API.
  ```

- **Pass** — An MCP server is documented and well-formed

  ```text
  MCP server documented with URL, OAuth auth, and Claude Code/Desktop setup commands.
  ```

- **Pass** — A CLI install path is documented

  ```text
  CLI install documented via brew, downloads, and Docker with start-dev usage.
  ```

- **Pass** — SDK packages resolve on their registries

  ```text
  Rust SDK crate resolves on docs.rs; Go API package resolves on pkg.go.dev.
  ```

- **Pass** — Agent skills are published

  ```text
  Temporal Developer Skill published with npx skills add and plugin install paths.
  ```



[Full report data](https://www.ax-check.com/temporal.io/report.json)