# AX Check: octa.com Checked 2026-10-08. Pricing is clear, but the agent integration endpoint is broken Prices show openly with no login needed. But the documented MCP endpoint returns a 404, so automated ordering flows can't connect as described. ## Onboarding needs a login ## Coding sessions All three independent sessions (DeepSeek V4.1 Flash, Kimi K3, Qwen 3.8 Max) completed and reported pricing, though their readings diverged: one described flat per-item retail prices, another described usage-based hourly/GB pricing billed in a token with a live USD conversion, and the third described tiered per-user monthly pricing for a separate identity product. No session hit a login wall. ### DeepSeek V4.1 Flash [View public run](https://agents.withgauge.com/p/runs/9e923c0a-8609-4917-8e11-a85c0d93020f) · [Read transcript](https://www.ax-check.com/octa.com/sessions/deepseek.json) Final output states concrete prices with explicit assumptions — octa.com hardware retail per-item ('Rhino $99.99', 'that's a Shopify cart, not metered/API pricing') and OCTA Core as 'quote-based/contact sales; no published self-serve tiers or usage-based API pricing' (seq 70). #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: No credentials were obtained or used, and no authenticated product operation was attempted. The agent determined there was no identifiable 'Octa' developer product (hosted SDK/API) to onboard to, and stopped before any sign-up, key retrieval, or API call to a product backend occurred. Event 70: ```text there is no single, unambiguous "Octa" developer product, and the prominent ones have no hosted SDK/API you can build a quickstart against ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No identifiable 'Octa' developer product exists**: Product ambiguity, not agent error: the agent probed every plausible domain/package name (octa.com, octa.ai, octa.dev, weareocta.com, npm, PyPI, GitHub) and found a Shopify hardware store, a kids' travel chatbot, an enterprise finance platform, and an unrelated CLI/toolbox — none expose a public, self-serve SDK or API. Search engines also redirected to the unrelated product Okta, compounding the ambiguity. This is a test-environment/product-identity issue rather than a fixable agent mistake. Event 70: ```text there is no single, unambiguous "Octa" developer product, and the prominent ones have no hosted SDK/API you can build a quickstart against ``` Event 70: ```text Search engines also auto-correct "Octa" → **Okta**, the identity platform, which *does* have a rich SDK/API. If that's what you meant, say so and I'll build the example. ``` #### Suggested Changes None identified in this transcript. ### Kimi K3 [View public run](https://agents.withgauge.com/p/runs/3a97c9be-7f38-4a1a-8706-49066b49250d) · [Read transcript](https://www.ax-check.com/octa.com/sessions/kimi.json) Final output states pricing is pay-per-use per hour/GB, billed in OCTA token with USD derived from live market rate (~$0.114/OCTA), and gives a live-data range ($0.12–$0.65/hr) explicitly tied to current marketplace snapshot, naming the token-price and per-operator assumptions behind the figure. #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: No API key was obtained during the session. The agent only called the public, unauthenticated network.get() endpoint successfully. It explicitly gated all authenticated calls (machine listing, apps listing, account balance) behind a conditional check for OCTA_API_KEY, which was never set, so that branch never executed. No credential acquisition flow (signup, token request) was attempted or demonstrated. Event 60: ```text === OctaSpace network stats (public) === Market price (OCTA): $0.11366352645239626 Nodes online: 457 ``` Event 62: ```text The main caveats: authenticated actions need you to supply an API key and a funded balance, and starting a rental session is a real billable action, so I'd want your go-ahead before calling anything beyond read-only endpoints. ``` Event 48: ```text (Set OCTA_API_KEY to also list rentable machines and apps.) ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No API key available to exercise authenticated endpoints**: The session had no OCTA_API_KEY credential supplied, so machine rental listing, apps listing, account balance, and session start/stop (all billable or authenticated operations) were never actually invoked, only described in code comments. This is a missing-credentials limitation of the test environment, not a product defect, and the agent correctly scoped its work to the public endpoint rather than attempting to fabricate credentials. Event 44: ```text // 2) Authenticated endpoints — only if an API key is provided if (process.env.OCTA_API_KEY) { ``` Event 62: ```text authenticated actions need you to supply an API key and a funded balance, and starting a rental session is a real billable action, so I'd want your go-ahead before calling anything beyond read-only endpoints. ``` - **api.octa.space/api-docs path redirects instead of resolving**: The agent tried to check the API docs URL referenced in the SDK readme and got a 301 redirect rather than a direct hit; it also tried octa.space/pricing and got a 404. The agent did not pursue these further since the SDK quickstart worked directly, so this did not block progress, but it indicates the docs link in the published SDK readme may not resolve cleanly for a quick sanity check. Event 29: ```text api.octa.space: 301 ``` Event 33: ```text 404: This page could not be found. OctaSpace: Decentralized GPU Cloud, AI & Compute Platform 404 This page could not be found. ``` #### Suggested Changes - **Fix or update the mmROI field in the public network.get() response**: Calling client.network.get() from @octaspace/sdk returns an mmROI field that evaluates to undefined when printed, even though the SDK readme's quick-start example explicitly prints it as a monthly staking ROI percentage. Verify the field name/shape returned by api.octa.space's network endpoint matches what the published SDK readme documents, and confirm by re-running the readme's own Quick Start snippet against the live API. Event 48: ```text Monthly staking ROI: undefined% ``` Event 22: ```text console.log(`Monthly staking ROI: ${stats.mmROI}%`) ``` ### Qwen 3.8 Max [View public run](https://agents.withgauge.com/p/runs/c8f4d1f1-ee1c-4f18-a9df-04af57e7b10f) · [Read transcript](https://www.ax-check.com/octa.com/sessions/qwen.json) Final output states dev orgs are free/no credit card, and production Workforce Identity pricing is per-user/month tiered by product, ballparked at $2-6/user/month for basic SSO, explicitly flagged as quote-based and approximate ("treat these as ballpark"). #### End-to-end onboarding - **Onboarding needs a login**: The agent never obtained Okta credentials or made any authenticated API call. It installed the public @okta/okta-sdk-nodejs package, inspected its API surface, and wrote an example script, but the script was only syntax-checked locally — never executed against a real Okta org. The agent explicitly states it cannot complete the free developer signup itself because it requires email verification and the web admin console (human steps), and that credentials must be supplied by the user. Event 74: ```text cd /sandbox/repo && node --check okta-example.js && echo OK ``` Event 77: ```text Sign up at **developer.okta.com/signup** → you get a free dev org like `https://dev-123456.okta.com`. I can't complete that signup myself (email verification + human console). ``` Event 77: ```text Once you hand me an org URL + API token, I can create/update/delete users, groups, apps, policies, and debug API errors entirely from this shell. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No Okta credentials available to run the example against a real org**: The product requires a signed-up developer org (org URL) plus an API token generated through the web admin console. This is a normal authentication requirement, not a product defect — the agent flags it clearly and stops short of faking success. Progress on the actual authenticated example is blocked purely by the lack of human-supplied credentials in this session. Event 77: ```text I can't complete that signup myself (email verification + human console). ``` Event 77: ```text To actually run it (2 minutes of your time, free) ``` - **Initial ambiguity between 'Octa' and 'Okta' product names**: The agent's first attempt found an empty repo and no documentation for a product called 'Octa', and initially stopped, suspecting the user meant a forex broker rather than a developer product. This was an agent interpretation issue (prompt ambiguity) rather than a product or environment defect, and the agent self-corrected in the next turn by testing the Okta SDK instead. Event 8: ```text The only well-known product called "Octa" is a retail forex/CFD broker (formerly OctaFX) — a trading platform for end users, not a developer product with a public SDK/API I could build a simple example against. ``` - **SDK v8 API surface mismatch with initial assumptions**: The agent's first draft of the example script called client.listUsers() and client.createUser() directly, which don't exist on the v8 Client object (methods moved to sub-API objects like client.userApi). This was caught via local inspection and corrected before being presented as final — a resolved agent error, not a lasting blocker. Event 47: ```text Client methods: ...total: 0 ``` Event 77: ```text SDK v8 moved methods off the top-level `Client` onto sub-API objects — it's `client.userApi.listUsers(...)`, not `client.listUsers(...)`. ``` #### Suggested Changes - **Clarify the product name collision between Octa and Okta in early search surfaces**: A first-time developer prompt for 'Octa' led the agent to assume a forex trading brand and almost stop the session entirely before self-correcting to Okta in the next turn. Check by searching 'Octa' through whatever channel developers land on first (search engine, docs search) and confirm Okta's name/branding is disambiguated early, reducing the chance a newcomer abandons the search. Event 8: ```text The only well-known product called "Octa" is a retail forex/CFD broker (formerly OctaFX) — a trading platform for end users, not a developer product with a public SDK/API I could build a simple example against. ``` - **Update SDK v8 quickstart examples to show the sub-API method pattern**: The agent found that commonly expected top-level methods (client.listUsers, client.createUser) no longer exist in @okta/okta-sdk-nodejs v8 — they moved to client.userApi.listUsers etc. Check the official quickstart/README for the Node SDK and confirm it shows the v8 sub-API call pattern explicitly, since the agent noted older tutorials online still show the pre-v8 style and would fail. Event 77: ```text SDK v8 moved methods off the top-level `Client` onto sub-API objects — it's `client.userApi.listUsers(...)`, not `client.listUsers(...)`. Most older tutorials online show the v4/v5 style and will fail on v8. ``` ### Task given to each agent Help me build a simple example using Octa. 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 · 67/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; no Markdown representation offered. ``` - **Pass** — llms.txt provides an actionable documentation index ```text llms.txt gives actionable index: product/collection JSON endpoints, search, sitemap, policies. ``` - **Pass** — llms.txt provides navigation guidance ```text llms.txt provides navigation guidance with a typical agent flow and endpoint list. ``` - **Pass** — llms.txt mentions offered API, MCP, and skills ```text llms.txt documents UCP MCP endpoint and the Shop skill for agents. ``` - **Pass** — A compact guide representation exists ```text llms.txt is a compact Markdown guide describing agent interaction with the Octa store. ``` - **Pass** — A focused guide is directly retrievable ```text llms.txt fetched directly at octa.com/llms.txt as text/markdown, 200 OK. ``` - **Pass** — Equivalent instructions fit a token budget ```text llms.txt is 1035 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. ``` - **Skipped** — The compact guide is independently actionable ```text No compact agent guide fetched; llms.txt is an index, not a standalone compact guide. ``` - **Skipped** — Install and next-step links resolve ```text No install or next-step links were sampled for resolution. ``` ### Onboarding - **Skipped** — Docs lead to a relevant quickstart ```text llms.txt describes agent commerce flow but no developer quickstart page was fetched. ``` - **Skipped** — Installation commands are extractable ```text No installation or CLI setup page was fetched for Octa. ``` - **Pass** — Code examples are available without interaction ```text llms.txt lists concrete read-only endpoints and MCP tools with example paths. ``` - **Pass** — Prerequisites and auth boundaries are explicit ```text llms.txt states read-only browsing needs no auth and checkout requires buyer approval. ``` ### Pricing - **Pass** — Pricing is readable without interaction ```text Homepage lists product prices ($29.00, $39.99, $19.99, etc.) directly in HTML without interaction. ``` - **Pass** — Prices are stated, not gated ```text Prices are stated openly on the homepage and product listings, not gated behind login. ``` - **Pass** — Pricing units and limits are explicit ```text Prices shown with currency (USD) and per-item amounts; kits list included components. ``` - **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 states concrete prices with explicit assumptions — octa.com hardware retail per-item ('Rhino $99.99', 'that's a Shopify cart, not metered/API pricing') and OCTA Core as 'quote-based/contact sales; no published self-serve tiers or usage-based API pricing' (seq 70). Kimi K3: Final output states pricing is pay-per-use per hour/GB, billed in OCTA token with USD derived from live market rate (~$0.114/OCTA), and gives a live-data range ($0.12–$0.65/hr) explicitly tied to current marketplace snapshot, naming the token-price and per-operator assumptions behind the figure. Qwen 3.8 Max: Final output states dev orgs are free/no credit card, and production Workforce Identity pricing is per-user/month tiered by product, ballparked at $2-6/user/month for basic SSO, explicitly flagged as quote-based and approximate ("treat these as ballpark"). This behavioural item does not affect the fast grade. ``` ### Activation - **Failed** — An MCP server is documented and well-formed ```text llms.txt documents an MCP endpoint at /api/ucp/mcp, but that endpoint returned 404. ``` - **Skipped** — An API reference or OpenAPI spec is reachable ```text llms.txt points to a UCP MCP endpoint, but no API reference or OpenAPI spec was fetched. ``` - **Skipped** — A CLI install path is documented ```text No Octa CLI install path is documented; the shop CLI belongs to Shop, not Octa. ``` - **Skipped** — SDK packages resolve on their registries ```text The only registry lookup was @shopify/shop-cli, a Shop package, not an Octa SDK. ``` - **Skipped** — Agent skills are published ```text llms.txt recommends the third-party Shop skill; no Octa-published agent skill is offered. ``` [Full report data](https://www.ax-check.com/octa.com/report.json)