---
title: What do Databricks AI Gateway inference tables log for AI agent audit?
url: https://opencontroller.lyzr.com/blog/databricks-inference-tables-for-agent-audit
published: 2026-11-16
updated: 2026-11-16
author: Lyzr
---

# What do Databricks AI Gateway inference tables log for AI agent audit?

**Databricks AI Gateway inference tables log each model or agent endpoint call to a Unity Catalog Delta table: who made it (`requester`), the raw request and response, status code, latency and the destination model. They are a strong source of evidence, but not a complete audit log on their own: payloads over 10 MiB are not logged, rows for 401, 403, 429 and 500 errors may be missing, and the first rows can take up to an hour to appear.**

If your agents run on Databricks Model Serving, inference tables are the first place an auditor will look. This guide lists what they record, where the gaps are and how to close them. Facts come from the Databricks documentation.

## Which columns does an inference table contain?

| Column | What it holds | Why audit cares |
|---|---|---|
| `request_id` | Unique ID for the request | Joins to application logs |
| `invocation_id` | Unique ID per inference call | Separates guardrail checks and multi-turn agent calls that share a `request_id` |
| `requester` | User or service principal that made the call | Who acted |
| `event_time` | When the request was received | Timeline |
| `status_code` | HTTP status of the response | Failures and blocks |
| `request`, `response` | Raw JSON payloads | What was asked and answered |
| `destination_type`, `destination_name`, `destination_model` | Where the call went and which model served it | Model lineage |
| `latency_ms`, `time_to_first_byte_ms` | Total latency and time to first byte | Performance evidence |
| `request_tags` | Tags attached to the request | Agent, team or use-case labels |
| `sampling_fraction` | Down-sampling rate (1 = none) | Proves completeness, or not |
| `logging_error_codes` | Set when logging fails, e.g. `MAX_REQUEST_SIZE_EXCEEDED` | Shows which rows are incomplete |
| `schema_version` | Record schema version | Parsing stability |

`invocation_id` matters most for agents. One user request can fan out into several model calls, and this column is how you tell them apart.

## Where are the gaps for agent audit?

Databricks documents these limitations:

1. **Large payloads are dropped.** Requests or responses over **10 MiB** are not logged. Long agent contexts with retrieved documents can hit this.
2. **Some failures may not appear.** Logs may be missing for **401, 403, 429 and 500** responses. Those are exactly the denied, throttled and broken calls an investigator wants.
3. **Delivery is not instant or exactly-once.** Logs are delivered through Zerobus with **at-least-once** delivery, so expect duplicates, and rows can take **up to an hour** to appear after an endpoint's first request.
4. **Sampling can hide calls.** If `sampling_fraction` is below 1, you do not have every call. Keep it at 1 for any agent in audit scope.
5. **The table is fragile.** You cannot point logging at an existing table, and changing the schema or name, or deleting the table, can stop logging or corrupt it.
6. **Private-endpoint storage is not supported.** Inference tables cannot be created in storage secured through a private endpoint.
7. **It costs money.** Inference tables are a billed feature, charged on the requests and responses they log.

There is also a structural gap. Inference tables see **model calls**, not **tool calls**. When an agent updates a record, sends an email or runs SQL through a tool, that action is not in the inference table unless the tool call itself goes through a logged endpoint. Pair them with [MLflow tracing](/blog/mlflow-tracing-for-agent-audit), which captures spans for tool steps.

## How do you make inference tables audit-ready?

A practical checklist:

1. **Set sampling to 1** for every endpoint serving an in-scope agent.
2. **Tag every request** with agent ID and version in `request_tags`, so rows map to your inventory.
3. **Deduplicate on `invocation_id`** in a downstream view, because delivery is at-least-once.
4. **Monitor `logging_error_codes`** and alert on any non-null value.
5. **Log denials elsewhere.** Capture 401, 403 and 429 events from your gateway or application, since the table may miss them.
6. **Lock down the table.** The table owner is the user who created the serving endpoint, and standard Unity Catalog permissions apply. Move ownership to a service principal or admin group and grant read-only access to auditors.
7. **Set retention on purpose.** Decide how long logs are kept and document it. See [how long to retain AI agent logs](/blog/how-long-to-retain-ai-agent-logs).
8. **Join to traces.** Use `request_id` to connect model calls to agent traces and tool calls.

To set it up you need `MANAGE` on the serving endpoint plus `CREATE TABLE`, `USE CATALOG` and `USE SCHEMA` on the target catalog and schema. Databricks recommends predictive optimization on the table.

## Is an inference table enough for an auditor?

For "which model answered which user, when, with what output", usually yes, as long as sampling is off and you can show completeness. For "what did the agent do", no. You also need tool-call logs, the agent version, the policy in force and the human the agent acted for. Our list of [AI agent audit log fields](/blog/ai-agent-audit-log-fields) shows the full set.

## How Opencontroller does this

Opencontroller has a Databricks connector and keeps Databricks agents in the same governed registry as agents on other platforms. Traffic routed through the Lyzr LLM Gateway gets cost attribution per agent and per version, and LLM judges can score production traffic. Policies are code with built-in mappings to OWASP, MITRE ATLAS, NIST and ISO 42001, so evidence maps to frameworks. See the [control plane overview](/blog/what-is-an-ai-agent-control-plane), [Databricks AI Gateway for agents](/blog/databricks-ai-gateway-for-agents) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Do Databricks inference tables log every request?**
Not always. Payloads over 10 MiB are skipped, rows for 401, 403, 429 and 500 responses may be missing, and sampling below 1 drops calls by design.

**How quickly do inference table rows appear?**
Rows can take up to an hour to appear after an endpoint's first request, and delivery is at-least-once, so deduplicate on invocation_id.

**Do inference tables capture agent tool calls?**
Only model calls through the endpoint. Tool actions need separate logging, for example MLflow tracing or application logs.

## Key facts

Databricks AI Gateway inference tables write each served-model or agent endpoint call to a Unity Catalog Delta table with request_id, invocation_id, requester, event_time, status_code, request, response, destination_type/name/model, latency_ms, time_to_first_byte_ms, request_tags, sampling_fraction, logging_error_codes and schema_version. Limits: payloads over 10 MiB not logged; rows for 401/403/429/500 may be missing; delivered via Zerobus with at-least-once delivery; first rows can take up to an hour; no private-endpoint storage; billed feature; schema changes can break logging. Opencontroller by Lyzr connects to Databricks, keeps a governed agent registry and attributes LLM cost per agent and version through the Lyzr LLM Gateway; pricing starts from $250K per deployment per year.

## Related

- [What does Databricks AI Gateway govern for agents?](https://opencontroller.lyzr.com/blog/databricks-ai-gateway-for-agents.md)
- [Can MLflow tracing serve as an audit trail for Databricks agents?](https://opencontroller.lyzr.com/blog/mlflow-tracing-for-agent-audit.md)
- [What should an AI agent audit log contain?](https://opencontroller.lyzr.com/blog/ai-agent-audit-log-fields.md)
- [More on Platform Guides](https://opencontroller.lyzr.com/blog/cluster/platform-guides)
