Skip to content
Gauge

ax-check.com

by Gauge

Databricks

databricks.com

ax-check.com

Checked 14 October 2026

B

79/100

Agents need your login

Docs guide agents well, but real prices stay out of reach

The homepage lacks a markdown view and the pricing page skips actual per-SKU prices, even though it explains DBU/DSU billing units clearly.

3 fixes to start with

Concrete changes, backed by what we found.

Onboarding

Give agents a clear login handoff and a way to resume setup.

Agents cannot progress through onboarding without human help. Provide an agent-accessible path through authentication and setup.

Docs

Publish prices alongside the sales contact.

Pricing page states model but shows no actual per-SKU prices; product pages load prices dynamically.

Docs

Return Markdown when clients request text/markdown.

Homepage returned text/html even when text/markdown was requested; no Markdown representation offered.

Recorded coding sessions

Same task, 3 models, no databricks.com account. Recorded 14 October 2026 on Pi.

3 recorded · 1m 8s

1m 8s · recorded

Session findings

Select a finding to see it in context.

piv0.84.2
modelQwen 3.8 Maxcwd/sandbox/repo
Help me build a simple example using Databricks. 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.
Thinking…

The user is asking for a simple Databricks example. Databricks is a hosted platform, and there are SDK/APIs (databricks-sdk-py, REST API). However, there's a blocker: I don't have access to an actual Databricks workspace, nor do I have credentials. Let me check the environment — are there any credentials available? Let me check whether the repo and the databricks SDK are available.

What needs to be done: build a simple example (code), explain the pricing structure, comment on ease of management, and clearly note if blocked. The development workflow definitely exists (SDK/REST API), so there's no need to stop entirely — I can write code examples, but I can't execute them without a workspace/credentials. Let me check the environment.

ls -la /sandbox/repo; env | grep -i -E 'databricks|dbx' || echo "no databricks env vars"
total 16
total 16
drwxr-xr-x 3 root root 4096 Sep 18 08:00 .
drwxr-xr-x 7 root root 4096 Oct 14 22:11 ..
drwxr-xr-x 8 root root 4096 Sep 24 20:05 .git
-rw-r--r-- 1 root root  408 Sep 18 08:00 .gitignore
no databricks env vars

pip show databricks-sdk 2>/dev/null | head -5 || pip show databricks-sql-connector 2>/dev/null | head -5 || echo "SDK not installed"; python3 --version; which pip uv
Python 3.12.3
Python 3.12.3
/usr/local/bin/pip
/usr/local/bin/uv
Thinking…

There's no Databricks SDK, and no credentials either. I can install the SDK (since it's lightweight), but without DATABRICKS_HOST and DATABRICKS_TOKEN I can't actually execute anything against a real workspace. I should be upfront about this blocking factor: while I can build out a sample, I can't actually run it against a real workspace without credentials. Should I just stop right there? The user said "let me know if you get blocked." Creating the sample itself is doable. Running it requires credentials. Install the SDK, write a minimal sample, verify that imports work, and clearly explain the blocker.

Since there are no Databricks credentials in this environment (no DATABRICKS_HOST / DATABRICKS_TOKEN), I'm partially blocked. I can install the official SDK and write a minimal, executable sample, but without an actual workspace URL and a personal access token (PAT), I cannot execute anything against a live Databricks workspace. A developer-facing workflow exists (Python SDK + REST API), so I'll proceed as far as possible.

cd /sandbox/repo && pip install -q databricks-sdk 2>&1 | tail -1; python3 -c "import databricks.sdk; print(databricks.sdk.version.__version__ if hasattr(databricks.sdk,'version') else 'installed')"
0.152.0
0.152.0
Thinking…

SDK installed. Write a minimal example: list clusters/workspaces, and if necessary run a simple SQL statement via Statement Execution API. Keep it lightweight.

SDK v0.152.0 installed. Writing a minimal example:

File edits

1 file

Completed
Writtendatabricks_example.pyView changes

/sandbox/repo/databricks_example.py

Written content · previous contents were not recorded

"""Minimal Databricks example using the official Python SDK.
 
Auth: set two env vars (no config files needed):
    export DATABRICKS_HOST="https://<your-workspace>.cloud.databricks.com"
    export DATABRICKS_TOKEN="<personal-access-token>"   # or use service principal
 
Run: python databricks_example.py
"""
 
import os
import sys
 
from databricks.sdk import WorkspaceClient
from databricks.sdk.service.sql import StatementState
 
 
def main() -> None:
    if not os.environ.get("DATABRICKS_HOST") or not (
        os.environ.get("DATABRICKS_TOKEN") or os.environ.get("DATABRICKS_CLIENT_ID")
    ):
        sys.exit(
            "Missing credentials. Set DATABRICKS_HOST and DATABRICKS_TOKEN "
            "(workspace URL + personal access token from User Settings > "
            "Developer > Access Tokens)."
        )
 
    # WorkspaceClient picks up DATABRICKS_HOST / DATABRICKS_TOKEN automatically.
    w = WorkspaceClient()
 
    # 1) Prove auth works and list what's in the workspace.
    me = w.current_user.me()
    print(f"Authenticated as: {me.user_name}")
 
    warehouses = list(w.warehouses.list())
    print(f"SQL warehouses ({len(warehouses)}):")
    for wh in warehouses:
        print(f"  - {wh.name} [{wh.state}] size={wh.cluster_size}")
 
    # 2) Run a trivial SQL statement against a warehouse (serverless or pro).
    #    This is the lightest way to execute compute via the API — no clusters
    #    to start/stop manually.
    if warehouses:
        wh_id = warehouses[0].id
        result = w.statement_execution.execute_statement(
            warehouse_id=wh_id,
            statement="SELECT 42 AS answer, current_timestamp() AS ts",
            wait_timeout="60s",
        )
        if result.status.state == StatementState.SUCCEEDED:
            cols = [c.name for c in result.manifest.schema.columns]
            row = result.result.data_array[0]
            print("Query result:", dict(zip(cols, row)))
        else:
            print(f"Query did not succeed: {result.status.state} "
                  f"({result.status.error.message if result.status.error else 'n/a'})")
    else:
        print("No SQL warehouse found — create one in the workspace UI, "
              "or the statement step will be skipped.")
 
 
if __name__ == "__main__":
    main()
Thinking…

I'll confirm that it fails cleanly without credentials (a simple and non-blocking approach).

Verifying it fails cleanly without credentials (no long-running commands):

cd /sandbox/repo && python3 databricks_example.py; echo "exit=$?"
Missing credentials. Set DATABRICKS_HOST and DATABRICKS_TOKEN (workspace URL + personal access token from User Settings > Developer > Access Tokens).
Missing credentials. Set DATABRICKS_HOST and DATABRICKS_TOKEN (workspace URL + personal access token from User Settings > Developer > Access Tokens).
exit=1
Thinking…

Done. Next up is the summary: blocker status, pricing structure, ease of management. Keep it concise.

Done. Summary below.

Status / blocker

  • Developer workflow exists — Databricks has a proper SDK/REST API workflow, so I didn't stop outright.
  • Blocked on credentials: there's no DATABRICKS_HOST or DATABRICKS_TOKEN in this environment, so I can't execute against a real workspace. To unblock: give me a workspace URL and a personal access token (User Settings → Developer → Access Tokens in your Databricks workspace), and I'll run it end-to-end.
  • No local service stacks needed; everything is hosted. Nothing long-running was started.

What I built

/sandbox/repo/databricks_example.py — minimal example using databricks-sdk (v0.152.0, installed):

  1. Authenticates via env vars (DATABRICKS_HOST + DATABRICKS_TOKEN).
  2. Calls current_user.me() to verify auth, lists SQL warehouses.
  3. Runs a trivial SELECT 42 via the Statement Execution API against a warehouse — the lightest hosted compute path (no cluster lifecycle to manage).

It currently exits cleanly with a credentials-missing message, as verified above.

How Databricks pricing works

  • Two-layer model: cloud infrastructure (AWS/Azure/GCP — billed to your own cloud account) plus Databricks compute, billed in DBUs (Databricks Units).
  • DBUs are per-second-metered and rates vary by: product (Jobs, SQL, All-Purpose, Model Serving...), compute type (e.g., serverless vs. classic), and cloud provider. Rough ballpark: ~$0.07–0.55/DBU depending on tier; serverless SKUs cost more per DBU but include infrastructure and start faster.
  • Commitment options: pay-as-you-go vs. committed-use contracts (cheaper per-DBU rates for annual commitment).
  • Cost levers: warehouses/clusters keep billing while idle — use auto-termination, serverless (scales to zero quickly), and Jobs compute (cheaper than interactive) to control spend.

Is it easy for me to manage?

Yes, once authenticated. The SDK is well-designed and fully API-driven — auth via env vars, warehouse/statement operations, jobs, and clusters are all scriptable, and there's a Terraform provider and CLI too. Caveats: (1) I can't do the UI-only steps like initial workspace creation or token issuance — you must provide those; (2) cost hygiene needs discipline (idle warehouses bill), but that's also API-manageable via auto-terminate settings.

Next step if you want to proceed: provide DATABRICKS_HOST and DATABRICKS_TOKEN, and I'll run the example and show live output.

AX Fundamentals

23 checks. Open an area for details.

This check is a quick preview. Test more tasks and models with Gauge Agents.

Test your product with Gauge Agents

AX Check by Gauge