Fabric Harness on Databricks

Build governed TypeScript agents with the Responses API, Unity AI Gateway, Unity Catalog, SQL Warehouses, Lakebase, AI Search, MLflow, Jobs, and Databricks Apps.

The 30 second answer

Databricks owns the data, models, identity, and hosting plane. Fabric is an optional durable control layer for agents that use that plane.

Question	Answer
Does Fabric replace Unity Catalog / Jobs / MLflow?	No. Those stay native and authoritative.
Does Fabric overlap AppKit?	Yes, at the agent-runtime layer (threads, tools, request-time approval).
When is Fabric still worth it?	When runs must survive failure, wait for exact-operation approvals, use isolated shell/fs work, keep portable policy, or leave recovery evidence across targets.
When should you skip Fabric?	Databricks-only interactive agents where AppKit’s request/thread lifecycle is enough.

Read the full decision guide: Why Fabric on Databricks.

Fabric Harness provides a first-party Databricks package, Databricks deployment targets, and Unity Catalog-aware connectors. It is designed for agents that need governed access to enterprise data, durable state, approval controls, lineage, and cost attribution without replacing Databricks authorization.

Databricks remains the native data, AI, compute, identity, governance, and hosting platform. Fabric is an optional durable control layer around those services. The current Databricks developer stack also includes a beta AppKit agent host with TypeScript definitions, tools, threads, cancellation, approvals, subagents, and Responses-compatible routes. That is direct overlap, not a gap Fabric should pretend still exists.

Fabric differentiates when execution must survive a failed process or long approval wait, policy must follow the workload across infrastructure, an agent needs isolated shell/filesystem work, or operators need portable recovery evidence.

Why add Fabric to a Databricks workload

Requirement	Fabric advantage
Recover after process or worker failure	Stable submissions, leases, bounded retry classification, checkpoints, replay, terminal states, and optional deterministic Temporal workflows
Wait safely for a person or external system	Exact-operation and principal-bound approvals can persist beyond one request stream and remain correlated with the resumed work
Govern effects outside a model-tool list	Definition policy constrains tools, commands, filesystems, networks, credentials, connectors, sandboxes, budgets, and timeouts
Perform isolated work	Sessions can run tasks and shell commands, mount sources, create attachments and artifacts, and checkpoint or fork capable sandboxes
Cross the workspace boundary	The same finite or persistent agent contract can run on Databricks, Node, Docker, Temporal, Cloudflare, Azure-oriented targets, Kubernetes patterns, and custom backends
Operate with evidence	Identity, events, lineage, cost, artifacts, cleanup records, certification, and terminal outcomes remain correlated to the submission

The current npm release is @fabric-harness/databricks@7.0.2. The exact 7.0.2 package and App artifacts passed all 21 release-blocking Tier R checks in protected Azure eastus2, including managed Genie MCP under OBO, governed SQL, live RAG, actual-cost reconciliation, and Lakebase-backed App restart recovery. The same run also passed current-run two-user App isolation and nine configured Tier O checks. A byte-identical same-commit Tier A run also passed all ten required governed authoring lifecycles with an empty cleanup ledger. See the retained compatibility evidence for the run, commit, digests, and explicit limitations. Stable Databricks services use exact-pinned official modular TypeScript SDKs; preview and workspace-dependent features remain labeled rather than inferred from mock tests.

Start at your level

Route	Start here	What you keep
Build your first agent	Scaffold, mock, connect, and deploy	One generated project, deterministic safe-tool test, reviewed environment template, and focused `NEXT_STEPS.md`
Choose a workload	RAG, analytics, operations, persistent Apps, or native access	The same agent structure with composable recipes and explicit resource ids
Production and advanced controls	Identity, policy, durability, certification, and native SDK composition	Required policy-bearing model tools, request-scoped OBO, Lakebase/Temporal options, and certification evidence

The beginner path is ordinary advanced TypeScript—not a separate wizard runtime. Add typed native clients through bundle.sdk, custom governed tools, durability, or additional certification without regenerating the project. Advanced control means making identity, resources, effects, and opt-outs more explicit; it does not disable the safe defaults.

Text alternative and Mermaid source

Diagram flow: User or system leads to HTTP, schedule, channel, or CLI; I leads to Fabric Harness agent; H leads to Policy and approvals; H leads to Durable session runtime; H leads to Governed tools; T leads to Unity AI Gateway; T leads to SQL Warehouse; T leads to AI Search; T leads to Genie Agents; T leads to Feature Serving; T leads to Lakeflow Jobs; S leads to Lakebase.

flowchart LR
  U[User or system] --> I[HTTP, schedule, channel, or CLI]
  I --> H[Fabric Harness agent]

  subgraph Control[Fabric control plane]
    H --> P[Policy and approvals]
    H --> S[Durable session runtime]
    H --> T[Governed tools]
  end

  subgraph Databricks[Databricks data and AI services]
    T --> M[Unity AI Gateway]
    T --> Q[SQL Warehouse]
    T --> V[AI Search]
    T --> G[Genie Agents]
    T --> F[Feature Serving]
    T --> L[Lakeflow Jobs]
    S --> B[Lakebase]
    T --> C[Unity Catalog]
  end

  C --> D[(Tables and volumes)]
  H --> O[MLflow and OpenTelemetry]

  classDef fabric fill:#dbeafe,stroke:#2563eb,color:#172554
  classDef data fill:#dcfce7,stroke:#16a34a,color:#052e16
  classDef control fill:#fef3c7,stroke:#d97706,color:#422006
  class H fabric
  class M,Q,V,G,F,L,B,C,D data
  class P,S,T control

What is first party

Area	Fabric Harness surface	Databricks service
Model runtime	`databricksFoundationModelProvider()`	Unity AI Gateway model services and custom Model Serving endpoints
Data access	`databricksSqlReadTool()`, `databricksSqlTool()`, `databricksSqlSandbox()`, `sandbox: 'databricks'`	SELECT-only analytics reads, approval-bound arbitrary SQL, and SQL Warehouses
Governance	`withGovernance()`, policy and approval helpers	Unity Catalog remains the authorization authority
Agent interoperability	`responses` endpoint, `databricks-app`, `databricks-serving`	Responses API and MLflow ResponsesAgent
Agent discovery and grants	`bundle.agentServices`	Unity Catalog Agent Services
Retrieval	`databricksAiSearch()`, `databricksEmbeddings()`	Databricks AI Search and Model Serving
Analytics	`databricksGenieTool()`, `DatabricksGenieAgentModeClient`, `databricksAiQueryTool()`	Ordinary Genie conversations, explicit Beta Agent Mode streaming, and AI Functions
Features	`databricksFeatureLookupTool()`	Feature Serving
Orchestration	Jobs, notebooks, and `databricksLakeflowTools()`	Jobs and Lakeflow pipelines
Resource management	Stable opt-in Jobs, Lakeflow, AI Search, custom-model serving, managed UC, workspace, and secret-reference tools; beta Genie Agent lifecycle	Governed create/verify/mutate/delete lifecycles with capability-specific evidence
Durable state	`lakebaseClient()`, `databricksPersistence()`	Lakebase Autoscaling
Files	Volume source/writer and `UcVolumesAttachmentStore`	Unity Catalog Volumes and Files API
Operations	MLflow tracing, usage capture, consumption, actual-cost budgets	MLflow and system tables
Hosting	`databricks-app`, `databricks-serving`	Databricks Apps and Model Serving proxy
Native access	`databricksSdk()`, `databricksWorkspaceApi()`	Generated service clients plus credential-safe access to the remaining workspace APIs

What Databricks teams can deliver

Starting workload	Recommended Fabric path	First proof to capture
Governed analytics copilot	Genie plus `databricksSqlReadTool()` and `analyticsCopilotGovernance()`	OBO identity, allowed `SELECT`, blocked mutation, inspectable SQL, actual-cost attribution
RAG or knowledge assistant	`databricksAiSearch()` plus `createDatabricksRagChain()` and AI Gateway	Known answer with citations, insufficient-context refusal, MLflow evaluation record
Durable App	`databricks-app` plus `databricksPersistence()` on Lakebase	Create a session, restart the App, recover conversation offsets and submissions
Data engineering operator	Jobs/Lakeflow tools with approval policy	Exact-input approval, idempotent run receipt, status/output collection, cleanup
Interoperable agent service	Responses API plus MLflow ResponsesAgent or Agent Services registration	Authenticated `/api/responses`, trace correlation, discovery and grant evidence

For a multi-team rollout, use the enterprise adoption guide. It maps workloads to platform prerequisites, identity choices, operating ownership, rollout phases, and production exit evidence.

Choose the right starting point

Read why Fabric on Databricks to understand what Fabric adds above native SDK clients, which responsibilities remain with Databricks, and when not to add a harness.
Use the enterprise adoption guide to align application, platform, security, and data-governance teams on a workload and production path.
Read Databricks development with Fabric Harness to understand the local-to-App workflow, supported workload patterns, AI Gateway integration, and where Fabric adds value.
Use native access and platform coverage for the generated clients, unrestricted workspace API escape hatch, coverage dimensions, and known gaps.
Build an interoperable App or serving agent with Responses API and ResponsesAgent.
Register an external agent for discovery and governance with Unity Catalog Agent Services.
Use the Databricks workload map to choose a typed API, managed recipe, or Databricks-native escape hatch.
Use Fabric Desktop for Databricks projects for a guided recipe, workspace discovery, mock/live run, build, preview, and Databricks App deployment workflow.
Use the quickstart to run a mocked agent and then connect a workspace.
Read architecture to understand identity, control, and data flow.
Use integrations as the feature and API map.
Use resource management for approval-gated creation, protected live lifecycle tests, cleanup, and production-readiness status.
Choose an execution surface with compute patterns.
Read connectors and sandboxes before choosing SQL execution, Volumes, or a general-purpose code sandbox.
Apply the enterprise controls for production identity, approvals, audit, durability, and cost limits.
Use the evidence-driven workspace compatibility matrix for cloud, region, auth, API, App, and Lakebase requirements.
Review authoring certification for automated test coverage, destructive protected-workspace lifecycles, cleanup behavior, and retained release evidence.

Workspace validation

Before deploying, run the Databricks certification command against the target workspace. It verifies OAuth scopes, Unity Catalog grants, API access, App resources, Unity AI Gateway model services, SQL Warehouses, and Lakebase connectivity while producing secret-redacted evidence for the deployment record. Follow authoring certification for the exact configuration, cleanup contract, and retained release evidence.