# AX Check: moderne.io
Checked 2026-10-02.

Moderne's quickstart and pricing are clear, but llms.txt is missing
14 of 23 checks passed: CLI install, quickstart steps, and pricing tiers are all stated plainly. No llms.txt index exists (404), and homepage has no Markdown version.

## Onboarding needs a login

## Coding sessions
All three independent sessions (DeepSeek V4.1 Flash, Kimi K3, Qwen 3.8 Max) completed their task and reported the same tiered pricing figures ($250K/$2M/$5M platform tiers, Backpatch from $2,000/mo to $1M) pulled directly from public docs, each with clear assumptions like developer and repo counts attached.

### DeepSeek V4.1 Flash
[View public run](https://agents.withgauge.com/p/runs/72b7a28d-577f-4489-bb40-f80a615b92c4) · [Read transcript](https://www.ax-check.com/moderne.io/sessions/deepseek.json)
README.md and final output give tiered dollar figures ($250K/$2M/$5M platform, $2K-$200K-$1M Backpatch) explicitly labeled 'typical' and tied to assumptions like dev count, LoC scale, and SLA level, sourced from moderne.io/pricing.
#### End-to-end onboarding
- **Onboarding needs a login**: Agent explored Moderne's docs, pricing, and GraphQL API schema thoroughly, then wrote a working example script against the hosted GraphQL API (https://api.app.moderne.io/). It confirmed the endpoint requires a Personal Access Token obtained by logging into a provisioned Moderne tenant, which is not self-serve (all plans are "Contact sales"). No token was obtained and no authenticated query was ever executed; the agent explicitly stopped rather than fabricate credentials.
  Event 38:

  ```text
  === unauthenticated API probe ===
  
  HTTP 401
  
  === GET probe ===
  
  HTTP 401
  
  ```
  Event 106:

  ```text
  I could not execute the queries, because access requires a Personal Access Token from a provisioned Moderne tenant, and Moderne has no free/self-serve tier — every platform plan is "Contact sales." I don't have a token, and I won't fabricate one.
  ```
  Event 88:

  ```text
  --- dummy token (live 401 check) ---
  ERROR: HTTP 401: token rejected or lacks access. Check that MODERNE_TOKEN is a valid, unexpired PAT. 
  exit=1
  
  ```

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

#### Blockers
- **No self-serve tenant or token — enterprise sales-only access**: Moderne's GraphQL API requires a Personal Access Token tied to a provisioned tenant, and every pricing tier is quoted as enterprise "Contact sales" with no free or self-serve option. This is product behavior (sales-gated access), not agent error or a test-environment artifact; the agent correctly identified it and stopped rather than guessing credentials.
  Event 56:

  ```text
  Commercial $250K Typical For organizations with up to about 1,000 developers and hundreds of repositories. ... Contact sales
  ```
  Event 38:

  ```text
  HTTP 401
  
  === GET probe ===
  
  HTTP 401
  ```
  Event 106:

  ```text
  Moderne has no free/self-serve tier — every platform plan is "Contact sales." I don't have a token, and I won't fabricate one.
  ```

#### Suggested Changes
- **Add a free or trial tier for individual developers to self-serve a token**: All published Moderne Platform and Backpatch Alliance tiers route to "Contact sales" per the pricing page content pulled at https://www.moderne.io/pricing. A developer with no existing enterprise relationship cannot create a tenant or Personal Access Token to try the GraphQL API. Verify by having a new, unaffiliated account attempt to sign up and generate a token without a sales conversation.
  Event 56:

  ```text
  id="panel-moderne-platform" role="tabpanel" aria-labelledby="tab-moderne-platform"> Moderne Platform Commercial $250K Typical ... Contact sales
  ```
- **Fix the broken link to the "Using the Moderne API" doc referenced from the API access page**: The accessing-the-moderne-api page's nav/breadcrumb lists a "Using the Moderne API" doc, but requesting https://docs.moderne.io/user-documentation/moderne-platform/how-to-guides/using-the-moderne-api returned a 404 Page Not Found. Check the docs sitemap/nav links on the Accessing the Moderne API page and confirm the correct slug resolves.
  Event 45:

  ```text
  Moderne Docs
  Skip to main content Recipes are moving from Maven Central to the Code Genome Project . Configure access to keep releases resolving. Page Not Found We could not find what you were looking for.
  ```

### Kimi K3
[View public run](https://agents.withgauge.com/p/runs/0f807bd0-c0d1-4be8-a7e4-43ec5dc4d0d5) · [Read transcript](https://www.ax-check.com/moderne.io/sessions/kimi.json)
Final output gives tiered pricing (~$250K/yr Commercial, ~$2M/yr Enterprise, ~$5M/yr Fully Managed) each with named assumptions (dev count, repo count, deployment model) and notes no self-serve/per-seat tier exists.
#### End-to-end onboarding
- **Onboarding needs a login**: The agent never obtained real product credentials. It searched the sandbox environment for tokens, found none, and confirmed the hosted GraphQL API (api.app.moderne.io/graphql) requires a Bearer token via a 401 response. No self-serve signup path was found or attempted; the product requires a sales-provisioned tenant and admin-issued API token, which the agent correctly identified as unavailable and stopped.
  Event 6:

  ```text
  PI_GATEWAY_API_KEY=unused
  GIT_CONFIG_KEY_0=safe.directory
  /usr/local/bin/node
  /usr/local/bin/python3
  
  ```
  Event 53:

  ```text
  < HTTP/2 401 
  < date: Fri, 02 Oct 2026 20:16:36 GMT
  < content-length: 0
  < vary: Origin
  < www-authenticate: Bearer
  
  ```
  Event 55:

  ```text
  No Moderne credentials exist in this environment (I checked).
  ```

#### Hallucinated URLs
- **Guessed API docs path returned a 'Page Not Found'**: The agent guessed a documentation URL for API access instructions that resolved to the docs site's own 404 page (not a raw HTTP 404, but a rendered 'Page Not Found' message), indicating the path was invented rather than discovered via navigation or search.
  Event 42:

  ```text
  https://docs.moderne.io/user-documentation/moderne-platform/how-to-guides/api-access
  ```
  Event 43:

  ```text
  Page Not Found We could not find what you were looking for. Please contact the owner of the site that linked you to the original URL and let them know their link is broken.
  ```

#### Blockers
- **Hosted GraphQL API requires a provisioned tenant token**: The core Moderne product workflow (GraphQL API at api.app.moderne.io/graphql) is gated behind Bearer authentication tied to a sales-provisioned tenant. This is standard product behavior (not a bug or test artifact) but it fully blocked any authenticated operation since no self-serve signup or trial token path exists or was discoverable.
  Event 53:

  ```text
  < HTTP/2 401 
  < www-authenticate: Bearer
  
  ```
  Event 55:

  ```text
  Moderne is a sales-gated enterprise platform. Its entire developer workflow (the `mod` CLI and the GraphQL API) requires an API token tied to a provisioned tenant, and there is no self-serve signup or free tier
  ```
- **Main api.moderne.io host was unreachable (proxy error)**: Initial attempts to reach the primary api.moderne.io hostname failed with 502 errors via the sandbox's mitmproxy layer, which is a test-environment networking artifact rather than a product defect; the agent correctly pivoted to the actual app subdomain (api.app.moderne.io) to continue investigating.
  Event 7:

  ```text
  502
  ```
  Event 23:

  ```text
  HTTP/2 502 
  server: mitmproxy 12.2.3
  content-type: text/html
  
  ```

#### Suggested Changes
- **Fix the broken API-access documentation link**: The guessed path docs.moderne.io/user-documentation/moderne-platform/how-to-guides/api-access resolves to the docs site's 'Page Not Found' page. Add or correctly link a how-to-guide page for API access/token generation under the moderne-platform docs section, and verify by requesting that URL and confirming it returns real content instead of the 404 template.
  Event 43:

  ```text
  Page Not Found We could not find what you were looking for. Please contact the owner of the site that linked you to the original URL and let them know their link is broken.
  ```
- **Publish a self-serve trial or sandbox token path for the GraphQL API**: api.app.moderne.io/graphql returns a bare 401 with no guidance on how to obtain a Bearer token short of enterprise sales contact. Add a lightweight signup or trial-token flow (or clear documentation link in the 401 response/docs) so a developer can get credentials without a $250K+ sales engagement, and verify by confirming a new token can be generated and used to run a sample query end-to-end.
  Event 53:

  ```text
  < HTTP/2 401 
  < www-authenticate: Bearer
  
  ```
  Event 32:

  ```text
  Moderne Platform Commercial $250K Typical For organizations with up to about 1,000 developers and hundreds of repositories.
  ```

### Qwen 3.8 Max
[View public run](https://agents.withgauge.com/p/runs/26e80442-9488-492c-890d-15be6c282edf) · [Read transcript](https://www.ax-check.com/moderne.io/sessions/qwen.json)
Final output gives tiered pricing ($250K/$2M/$5M platform tiers, $2,000/mo Backpatch) with explicit assumptions (dev/repo counts, hybrid SaaS region, forward-deployed engineer inclusion) pulled from moderne.ai/pricing scrape at seq 20-27.
#### End-to-end onboarding
- **Onboarding needs a login**: The agent never obtained real Moderne credentials. It only found a pre-existing unrelated PI_GATEWAY_API_KEY env var, and separately confirmed api.moderne.io itself was unreachable (502) from the sandbox. No account, API key, or authenticated call to the actual Moderne product was ever made.
  Event 6:

  ```text
  PI_GATEWAY_API_KEY=<set>
  ```
  Event 29:

  ```text
  No credentials: no Moderne API key or account exists in this environment (only PI_GATEWAY_API_KEY, which is unrelated).
  ```
  Event 29:

  ```text
  No network path: api.moderne.io returns 502 from this sandbox — the API is unreachable even if I had a key.
  ```

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

#### Blockers
- **Moderne API endpoint unreachable (502 Bad Gateway)**: Every attempt to reach api.moderne.io, including the docs and health endpoints, returned a 502 Bad Gateway from the sandbox network. This is either a product-side outage or an environment network restriction, not an agent error, since the agent tried multiple plausible paths (root, /v1/docs, /actuator/health).
  Event 7:

  ```text
  502
  ```
  Event 11:

  ```text
  https://api.moderne.io/v1/docs -> 502
  ```
  Event 17:

  ```text
  <title>502 Bad Gateway</title>
  ```
- **No self-serve signup or API key provisioning for Moderne**: Moderne's product is entirely sales-gated: both the Platform and Backpatch Alliance pricing tiers route to 'Contact sales' with no free tier, trial, or self-service signup form found. This is a product/business-model constraint, not a credentials failure caused by the test environment.
  Event 27:

  ```text
  Contact sales
  ```
  Event 29:

  ```text
  a heavyweight, sales-gated onboarding, not a quickstart I can act on. There's no free API tier I can hit anonymously.
  ```

#### Suggested Changes
- **Publish a reachable public status or demo API endpoint**: The agent could not evaluate the actual developer workflow because api.moderne.io returned 502 on every route tested (root, /v1/docs, /actuator/health). Product owner should verify api.moderne.io uptime and consider exposing a lightweight public health-check or sandbox endpoint so prospective developers can confirm the API is live before engaging sales.
  Event 11:

  ```text
  https://api.moderne.io -> 
  ```
  Event 17:

  ```text
  <p>connection closed</p>
  ```
- **Add a free or self-serve tier for individual developer evaluation**: Pricing page (moderne.io/pricing) only lists six-figure-to-million-dollar 'Contact sales' tiers plus a $2,000/mo Backpatch Alliance membership; there is no way for an individual developer to try the Moderne Platform without a sales conversation. Adding even a limited free tier or trial key would let developers like this agent complete a real quickstart.
  Event 27:

  ```text
  Commercial
        $250K
        Typical
  ```
  Event 27:

  ```text
  Contact sales
  ```

### Task given to each agent
Help me build a simple example using Moderne. 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 · 65/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 Markdown Accept header; no Markdown representation offered.
  ```

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

  ```text
  /llms.txt returns HTTP 404, so no documentation index is published.
  ```

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

  ```text
  /llms.txt is 404, so no navigation guidance exists to assess.
  ```

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

  ```text
  /llms.txt is 404, so no API, MCP or skills mentions can be assessed.
  ```

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

  ```text
  Markdown quickstart and CLI guide served as text/markdown at .md URLs.
  ```

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

  ```text
  Quickstart and CLI intro give concrete install, login, and recipe-run steps.
  ```

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

  ```text
  Markdown quickstart is 1609 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 judged.
  ```

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

  ```text
  CLI guide gives install, auth, sync, build, run, and commit steps with concrete commands.
  ```

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

  ```text
  Fetched quickstart and CLI intro pages returned 200 with working next-step links.
  ```


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

  ```text
  Docs quickstart 'Using the Moderne Platform' gives 7 concrete steps from sign-in to commit.
  ```

- **Pass** — Installation commands are extractable

  ```text
  CLI guide shows extractable install commands: curl app.moderne.io/cli, brew, choco.
  ```

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

  ```text
  Quickstart and CLI pages show inline code blocks and commands without interaction.
  ```

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

  ```text
  CLI guide states sign-in, GitHub permissions, and token/PAT auth boundaries explicitly.
  ```


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

  ```text
  Pricing page renders all tiers and prices directly in fetched HTML, no interaction needed.
  ```

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

  ```text
  Prices stated publicly: $250K, $2M, $5M typical; Backpatch $2,000/mo, $200K, $1M.
  ```

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

  ```text
  Units and limits explicit: developer counts, repositories, per-month, per legal entity.
  ```

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

  ```text
  3 of 3 sessions were judged on pricing; 0 fell short. DeepSeek V4.1 Flash: README.md and final output give tiered dollar figures ($250K/$2M/$5M platform, $2K-$200K-$1M Backpatch) explicitly labeled 'typical' and tied to assumptions like dev count, LoC scale, and SLA level, sourced from moderne.io/pricing. Kimi K3: Final output gives tiered pricing (~$250K/yr Commercial, ~$2M/yr Enterprise, ~$5M/yr Fully Managed) each with named assumptions (dev count, repo count, deployment model) and notes no self-serve/per-seat tier exists. Qwen 3.8 Max: Final output gives tiered pricing ($250K/$2M/$5M platform tiers, $2,000/mo Backpatch) with explicit assumptions (dev/repo counts, hybrid SaaS region, forward-deployed engineer inclusion) pulled from moderne.ai/pricing scrape at seq 20-27. This behavioural item does not affect the fast grade.
  ```


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

  ```text
  No API reference or OpenAPI spec was fetched; docs mention APIs only in passing.
  ```

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

  ```text
  No MCP server documentation was fetched; CLI lists an 'mcp' command only.
  ```

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

  ```text
  CLI install documented: curl script, Homebrew, Chocolatey, plus mod verification.
  ```

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

  ```text
  No registry lookup for a Moderne SDK or CLI package was supplied.
  ```

- **Skipped** — Agent skills are published

  ```text
  No agent skills publication was fetched; only agent tools docs are referenced.
  ```



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