# AX Check: calico.cs.berkeley.edu Checked 2026-09-18. No docs index or quickstart found; homepage only offers HTML. The homepage loads fine, but there's no Markdown version, no documentation index, and no quickstart or install guide an agent could follow directly. ## End-to-end onboarding not demonstrated ## Coding sessions All three independent sessions completed and reported on pricing, describing free open-source tiers alongside paid cloud or enterprise tiers, but each flagged exact rates as unverified rather than confirmed on a live pricing page. ### DeepSeek V4 Pro [View public run](https://agents.withgauge.com/p/runs/300a37b9-c904-40d9-b488-9076055ee36d) · [Read transcript](https://www.ax-check.com/calico.cs.berkeley.edu/sessions/deepseek.json) Final table states Open Source is free, Free Tier is free with named limits (1 cluster, 24h flow-log retention, view-only), and Pro/Enterprise is sales-quoted rather than inventing a dollar figure. #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: The agent never obtained Calico Cloud credentials or exercised any authenticated API/SDK. It only read public docs and pricing pages via curl, then concluded that the product's actual workflow requires a Kubernetes cluster plus a web-console sign-up and kubectl/Helm commands with an account-specific API key -- none of which it attempted, correctly citing the session's own restriction against starting local service stacks or long-running commands. Event 89: ```text The official quickstart explicitly requires installing Kind + Docker + kubectl, creating a local Kind cluster (`kind create cluster`), running `watch kubectl get tigerastatus` and `watch "kubectl get pods -A …"` — i.e., starting a local service stack and waiting on long-running commands, both of which you told me not to do. ``` Event 89: ```text There's no public managed REST API or SDK I can authenticate to and exercise without first connecting a cluster, so I have no hosted surface to act on. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No hosted SDK/API — onboarding requires a live Kubernetes cluster**: Product behavior, not agent error: Calico Cloud's only integration surface is applying kubectl/Helm manifests generated per-account inside a Kubernetes cluster. Since the quickstart mandates spinning up a local Kind cluster and running long-poll watch commands (both explicitly disallowed for this session), the agent had no lightweight SDK/API path to exercise and correctly halted rather than fabricate a workaround. Event 68: ```text Get Calico Cloud running on a local Kind cluster, deploy a realistic microservices app, and explore your live Service Graph — all in a few minutes. ``` Event 68: ```text kind create cluster --name=calico-cluster --config=kind-config.yaml ``` Event 68: ```text watch kubectl get tigerastatus ``` - **Paid tier pricing not published**: Product behavior: the public pricing page for Calico Cloud Pro/Enterprise contains no dollar figures, per-node, or per-cluster rates — it is sales-quoted only. The agent's targeted greps for pricing terms on tigera.io and calicocloud.io returned no matches, confirming the page has no listed numbers. Event 42: ```text Get started for free or request a demo to see Calico in action ``` Event 87: ```text (no output) ``` #### Suggested Changes - **Publish a lightweight, cluster-free way to exercise the Calico Cloud API**: On the get-started/quickstart docs (e.g. docs.tigera.io/calico-cloud/free/quickstart), add an option that lets a developer call the Calico Cloud management API or SDK directly (API key + REST/gRPC call) without first standing up a Kind cluster and running kubectl apply. Verify by confirming a first-time developer can complete a real API call end-to-end in under a few minutes without a local cluster. Event 68: ```text Install [Kind](https://kind.sigs.k8s.io/docs/user/quick-start/), [Docker](https://docs.docker.com/desktop/), and [kubectl](https://kubernetes.io/docs/tasks/tools/#kubectl). ``` - **Add explicit pricing numbers to the public pricing page**: On www.tigera.io/pricing, list at least indicative per-node or per-cluster rates for Calico Cloud Pro/Enterprise instead of routing every visitor to 'request a demo.' Verify by checking that a curl/grep for dollar amounts or tier names on the page returns real figures. Event 42: ```text Get started for free or request a demo to see Calico in action ``` ### Kimi K3 [View public run](https://agents.withgauge.com/p/runs/9f90d6cb-bff8-412a-9789-5f88a3e21269) · [Read transcript](https://www.ax-check.com/calico.cs.berkeley.edu/sessions/kimi.json) Final output's Pricing section states OSS is free, Cloud is usage-based via free trial/AWS Marketplace, Enterprise is per-node annual, and explicitly flags exact rates as unverified since the pricing page is JS-rendered. #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: The agent never attempted to obtain or use any product credentials. It only ran read-only network checks (curl to tigera.io and docs.tigera.io) and concluded Calico has no standalone hosted API/SDK to onboard against, since it is a Kubernetes CNI plugin requiring a cluster and kubectl/calicoctl access. No credential acquisition or authenticated operation occurred. Event 11: ```text curl -s -m 15 https://www.tigera.io/pricing/ | sed -e 's/<[^>]*>//g' | tr -s ' \n' ' \n' | grep -iA2 -B2 -E 'price|free|node|hour|vCPU|trial' | head -n 80 ``` Event 15: ```text Even Tigera's hosted option, Calico Cloud, is a management plane you *connect your own cluster to* — there's no standalone REST API you can sign up for and call with an API key. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **Calico has no standalone hosted API/SDK to build against**: Product behavior, not agent error or missing credentials: Calico (open source, Cloud, or Enterprise) is fundamentally a Kubernetes CNI/network-policy engine. Every workflow requires an existing Kubernetes cluster plus kubectl/calicoctl, and even the hosted 'Calico Cloud' option is a management plane attached to a user-supplied cluster rather than something callable via a standalone REST API/SDK. The sandbox also lacked kubectl/kind/minikube, and starting a local cluster was explicitly disallowed by the task instructions, so the agent correctly stopped rather than building a local stack. Event 15: ```text Calico (Project Calico / Tigera) has no hosted SDK-or-API developer workflow I can act on. ``` Event 15: ```text This environment also has no `kubectl`/`kind`/`minikube` installed — only Docker. ``` - **Pricing page is JS-rendered, blocking scrape of exact rates**: Test environment/product website limitation: the agent tried to scrape tigera.io/pricing for concrete numbers but the page returned only JS/CSS scaffolding with no readable pricing text, since content is rendered client-side. This prevented confirming exact per-node or per-hour rates. Event 13: ```text var ElementorProFrontendConfig = {"ajaxurl":"https:\/\/www.tigera.io\/wp-admin\/admin-ajax.php" ``` Event 15: ```text I couldn't scrape exact per-node rates from the pricing page (it's JS-rendered), so treat the figures above as the pricing *model*, not verified numbers. ``` #### Suggested Changes - **Add a server-rendered pricing summary for scrapers and quick reference**: On tigera.io/pricing, include a static, non-JS-rendered summary table of Calico Cloud/Enterprise pricing tiers (e.g. in page HTML or a linked PDF/markdown doc). Verify by fetching the page with a plain HTTP client (curl) and confirming pricing figures appear in the raw response body rather than only after JS execution. Event 13: ```text styleTags.forEach(function(styleTag) { ``` - **Clarify upfront that Calico requires an existing Kubernetes cluster**: On the main quickstart/getting-started page, state plainly near the top that Calico is a CNI/network-policy layer requiring a pre-existing Kubernetes cluster and kubectl/calicoctl access, and that there is no standalone SDK/API workflow independent of a cluster. This helps developers self-select before starting a quickstart, and can be checked by confirming the statement appears before any installation steps. Event 15: ```text Every quickstart — open-source Calico, Calico Cloud, or Calico Enterprise — begins with "have a Kubernetes cluster," then `kubectl apply` of the Calico manifests and interaction via `kubectl`/`calicoctl` against that cluster. ``` ### Qwen 3.8 Max [View public run](https://agents.withgauge.com/p/runs/f6d6ce9f-cf1b-4edb-aa2b-9efc3843c68c) · [Read transcript](https://www.ax-check.com/calico.cs.berkeley.edu/sessions/qwen.json) Final output gives per-tier pricing (OSS free, Calico Cloud per-node/year with ~30-day trial, Enterprise quote-based) and flags it as 'from knowledge, not verified live' with trial-limit assumption named. #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: Agent never attempted to obtain or use Calico/Tigera credentials. It only checked local environment variables and CLI tools, found none, and stopped without any self-service signup, API call, or authenticated operation against a hosted product. Event 4: ```text env | grep -i -E 'calico|tigera|api_key|token' | sed 's/=.*/=/' ; which kubectl kind minikube helm 2>/dev/null ``` Event 8: ```text No hosted sandbox or pure-REST path exists to demo against. - No Calico Cloud token or kubeconfig is available here anyway. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No Kubernetes cluster or Calico credentials available**: Calico's developer workflow requires a live Kubernetes cluster (local or hosted) plus either a kubeconfig or a Calico Cloud API token to install and interact with its CRDs. None were present in the sandbox, and the task explicitly forbade starting local service stacks or long-running commands, so the agent could not proceed. This is a combination of missing credentials and a genuine product characteristic (no pure API/SDK-only path exists without cluster installation), not an agent mistake. Event 6: ```text PI_GATEWAY_API_KEY= --- @anthropic-ai @earendil-works @openai corepack npm ``` Event 8: ```text Calico's quickstart requires a running Kubernetes cluster — either a local stack (`kind`/`minikube`) or registering a cluster with hosted Calico Cloud. Both mean starting local service stacks or long-running provisioning, which you told me not to do. ``` #### Suggested Changes - **Add a hosted sandbox or API-only quickstart for Calico Cloud**: Provide a lightweight, no-install way to exercise Calico Cloud's API (e.g., a demo tenant with a scoped token) so developers without an existing Kubernetes cluster can try core policy features without provisioning kind/minikube or a full cluster. Validate by having a fresh agent obtain a token via a documented self-service signup and successfully create/query a policy object through the API alone. Event 8: ```text There is no meaningful "SDK/API-only" path: Calico's API (the Kubernetes API with its CRDs like `NetworkPolicy`, `GlobalNetworkPolicy`, `NetworkSet`) only exists once Calico is installed into a cluster, and Calico Cloud onboarding also requires installing agents into a cluster. ``` ### Task given to each agent Help me build a simple example using Calico. 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: F · 0/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 even when text/markdown was requested; no Markdown representation offered. ``` - **Failed** — llms.txt provides an actionable documentation index ```text /llms.txt returns HTTP 404, so no documentation index exists. ``` - **Skipped** — llms.txt provides navigation guidance ```text No llms.txt body exists (404), so navigation guidance cannot be assessed. ``` - **Skipped** — llms.txt mentions offered API, MCP, and skills ```text No llms.txt body exists (404); no API, MCP or skills surfaces are offered to mention. ``` - **Skipped** — A compact guide representation exists ```text No site-published Markdown guide fetched; homepage Markdown unsupported and only HTML/PDF guides linked. ``` - **Skipped** — A focused guide is directly retrievable ```text No compact guide representation was fetched; only HTML pages and a PDF guide are linked. ``` - **Skipped** — Equivalent instructions fit a token budget ```text No compact guide was retrieved, so no token budget could be measured. ``` - **Skipped** — Product-docs links survive format changes ```text Homepage Markdown is unsupported, so link preservation across formats cannot be judged. ``` - **Skipped** — The compact guide is independently actionable ```text No compact agent guide fetched; only homepage and a 404 llms.txt were retrieved. ``` - **Skipped** — Install and next-step links resolve ```text Homepage links (Contest Guide, Register, FAQ) were not fetched, so resolution is unverified. ``` ### Onboarding - **Skipped** — Docs lead to a relevant quickstart ```text No fetched Calico docs or quickstart pages; only a 404 llms.txt and a foreign Algoverse page. ``` - **Skipped** — Installation commands are extractable ```text No Calico installation or setup page was fetched; nothing to extract commands from. ``` - **Skipped** — Code examples are available without interaction ```text No Calico documentation or code-example page was fetched in this bundle. ``` - **Skipped** — Prerequisites and auth boundaries are explicit ```text No Calico docs fetched, so prerequisites and auth boundaries cannot be judged. ``` ### Pricing - **Skipped** — Pricing is readable without interaction ```text Not applicable: the relevant product is free. CALICO is a free high-school programming competition; no pricing page or paid plans exist. ``` - **Skipped** — Prices are stated, not gated ```text Not applicable: the relevant product is free. No prices are stated because the competition is free to enter; no paid tiers offered. ``` - **Skipped** — Pricing units and limits are explicit ```text Not applicable: the relevant product is free. No pricing units or limits exist; CALICO is a free student competition, not a paid product. ``` - **Skipped** — Agents identify pricing and its assumptions ```text Not applicable: the relevant product is free. CALICO is a free high-school programming competition; no pricing page or paid plans exist. ``` ### Activation - **Skipped** — An API reference or OpenAPI spec is reachable ```text No API reference or OpenAPI spec was fetched for calico.cs.berkeley.edu. ``` - **Skipped** — An MCP server is documented and well-formed ```text No MCP server documentation was fetched for calico.cs.berkeley.edu. ``` - **Skipped** — A CLI install path is documented ```text No CLI install path was fetched for calico.cs.berkeley.edu. ``` - **Skipped** — SDK packages resolve on their registries ```text No SDK package registry lookup was fetched for calico.cs.berkeley.edu. ``` - **Skipped** — Agent skills are published ```text No agent skills documentation was fetched for calico.cs.berkeley.edu. ``` [Full report data](https://www.ax-check.com/calico.cs.berkeley.edu/report.json)