1h 28m read

Your Lineage No Longer Ends at the Dashboard

Why dashboard-era lineage leaves a dangling end when AI agents answer questions, and what an agent-level lineage record must carry: the run, the authorization scope, the resolved metric definition version, and a point-in-time anchor — plus vendor questions and what the EU AI Act and SR 26-2 actually require.

Your Lineage No Longer Ends at the Dashboard

Introduction

Lineage built for human dashboard consumers stops being sufficient the moment AI agents and natural-language query tools read the same governed data and produce answers nobody can trace.

That is the whole argument in one sentence, and it is worth being precise about why it holds. A dashboard is a fixed artifact. It is built once, it has an owner, it sits in a folder, and the chain from source table to chart is the complete story of how a number reached a human being. An agent's answer is none of those things. It is generated per query, per user, per moment. It has no dashboard, no folder, and no obvious place in the graph. When a business user asks a natural-language question and receives a number, the lineage graph typically has a dangling end: the data path is recorded up to some table or semantic model, and then nothing.

The usual response is to ask for more lineage — another connector, another parser, another catalog integration. That response misdiagnoses the problem. The gap is not coverage of data movement; it is the scope of the lineage record itself. What is missing is not an edge but a different kind of record: one that carries the agent's run, the authorization scope it acted under, the metric definition it resolved, and a point-in-time anchor that lets an auditor reconstruct what was possible at the moment the answer was produced.

This article develops that model. It explains why the dashboard boundary was organizational convenience rather than a property of data, what specifically changes when the consumer is an agent, and what a lineage record for an agent answer must contain. It then works through access-aware lineage, change impact, point-in-time reconstruction, and what the current rules actually require — which is less, and differently scoped, than vendor marketing often implies. It closes with questions a data or IT leader can put to a platform vendor and get a testable answer to.

The Dashboard Was a Convenient Boundary, Not a Natural One

Lineage stopped at the dashboard because the dashboard was where the human stopped. A chart was the terminal artifact of a chain: a table was loaded, transformed, aggregated, and rendered. The chart had a named owner, a refresh schedule, and a place in a BI tool's inventory. Recording the path from table to chart was sufficient because everything downstream of the chart was a person looking at a screen, and people do not need to be represented as nodes in a metadata graph.

That boundary held for two reasons, neither of which is about data. First, dashboards are enumerable. An organization can list its dashboards, assign owners, and review them. Second, dashboards are stable. A chart that showed revenue by region last quarter shows revenue by region this quarter, reading the same upstream tables through the same transformation logic. The lineage edge was static because the artifact was static.

Neither property survives contact with a natural-language interface. An agent answering "which regions missed their margin target last month and why" does not consult a pre-built chart. It resolves the question against metric definitions, selects tables and columns, issues queries, possibly chains several tool calls, and composes a response. The next question produces a different path. The artifact that a human reads is generated at the moment of the query and, unless something records it, ceases to exist when the session closes.

The consequence is a dangling end in the graph. Upstream lineage may be excellent — column-level, cross-platform, stitched from transformation tools and warehouse query logs. Downstream of the semantic layer, the graph simply stops, because the consumer was never modeled as a node. This is a scope problem in the lineage model, not a tooling gap. Adding another connector extends the graph along the same axis it already covers. It does not add the axis that is missing: the invocation.

What Changes When the Consumer Is an Agent

Four properties of agent consumption break the dashboard-era model, and each maps to a requirement the lineage graph must satisfy.

Machine-scale, unanticipated combinations. A dashboard reads a known set of tables in a known pattern. An agent reads whatever the question requires, across joins and columns that no dashboard designer anticipated, at a volume of distinct query shapes that no human review process can enumerate. The graph cannot rely on pre-registration of consumers, because the consumer set is effectively unbounded.

Definition resolution at query time. A dashboard embeds a metric definition in its SQL or its semantic model. An agent resolves a question against a definition — often a governed metric in a semantic layer — and the resolution is a decision made at runtime. Which version of the definition was in force, and whether the agent used it or a cached copy, determines whether the answer is correct under current definitions or stale ones.

A distinct identity and authorization scope. The agent may act under its own service identity, under a delegated scope from the requesting user, or under some combination. That scope can differ from the requester's, and it can differ between two invocations of the same agent. Whether the answer is legitimate depends on whether every input it read was within the scope the agent was entitled to use.

Ephemeral output. The answer is text, a table, or a chart rendered in a chat window. Unless the run is recorded, there is no artifact to investigate after a complaint, no way to answer "what did the system say last Tuesday and on what basis," and no way to identify which downstream decisions were informed by a now-superseded definition.

These four properties correspond to four records that the rest of this article develops: the run (which invocation, when, by whom or what), the scope (the identity and authorization under which reads occurred), the definition (which metric version was resolved, and how), and the time anchor (the data state and configuration at the moment of the answer). A lineage model that carries all four can trace an agent answer back to its inputs and forward to its consequences. A model that carries none of them can do neither, no matter how many tables it connects.

The Lineage Record an Agent Answer Requires

What follows is a proposed model, not an observed standard. No widely adopted specification currently defines a lineage record for an agent answer end to end. The OpenLineage object model is a useful reference point because it already separates the entities this problem needs, and because its facet mechanism is designed for exactly the kind of extension the agent case requires. Treat it as a structural guide, not a compliance target.

OpenLineage models lineage around Jobs, Runs, and Datasets, with facets attaching metadata to each. A Job is the activity; a Run is a specific instance of that activity, identified by a run ID; Datasets are the inputs and outputs. Run state updates are additive — inputs can be declared at start, at completion, or both — which accommodates information that only becomes available partway through execution. That property matters for agents, whose tool calls and data reads are discovered as the run proceeds rather than declared in advance.

A lineage record for an agent answer should carry, at minimum:

  • A run identifier for the agent invocation, stable and queryable after the fact. OpenLineage's run facets documentation notes that every run has a uniquely identifiable run ID, typically a UUID, and recommends UUIDv7. The agent invocation is the natural Job here, with one Run per question answered.

  • The resolved metric definition and its version. This is the record most often missing. It should capture the definition identifier, the version in force at resolution time, and whether the agent resolved it live or read a cached copy. Neither the core OpenLineage model nor its standard facets carry a metric-definition version, so this belongs in a custom facet.

  • The input datasets and columns actually read. OpenLineage's column-level lineage facet expresses column dependencies on a dataset. For agents, the distinction between columns the agent was permitted to read and columns it actually read is material, and the record should reflect the latter.

  • The tool or query path taken. Which queries were issued, in what order, through which tools. OpenLineage's sql job facet captures a SQL query where the job is a SQL query; multi-step agent runs will need to record a sequence rather than a single statement.

  • The identity and authorization scope under which each read occurred. This is the subject of the next section and is not covered by standard facets.

OpenLineage's facet model accommodates the first, third, and fourth items with standard or lightly extended facets. Custom facets must use a distinct prefix named after the defining project, carry a _schemaURL pointing to an immutable, versioned schema location — a tag or commit SHA, not a branch name — and follow the {prefix}_{name} key convention. The definition-version record and the authorization-scope record are the clearest candidates for custom facets with versioned schema URLs, precisely because they are organization- or vendor-specific today and may be standardized later.

Why the Run, Not the Dashboard, Becomes the Unit of Record

The shift in granularity is the heart of the change. Dashboard-era lineage recorded a static edge: table A feeds chart B. Agent-era lineage must record an instance: one run, one question, one answer, one set of reads, one resolved definition, one authorization scope.

OpenLineage already treats runs as distinct observations — its object model notes that a job repeating daily should produce a separate Run for each day. The agent case extends this to a much higher frequency: a separate Run for each question, potentially thousands per day per agent.

The practical consequence is that the graph grows by invocation rather than by artifact. Retention, sampling, and storage become design decisions rather than afterthoughts. An organization that records every agent run at full fidelity for seven years will accumulate a very large graph; one that records nothing has no audit trail. The defensible middle is a tiered policy: full-fidelity records retained for the period your audit and regulatory obligations require, aggregated or sampled records beyond that, and a documented statement of what the retention horizon is. That horizon is also the boundary of what can be reconstructed later, which the point-in-time section returns to.

Access-Aware Lineage: Authorization Belongs in the Graph

Access-aware lineage is the proposed practice of recording the consumer's authorization scope as part of the lineage record, rather than holding it only in a separate policy system that the lineage graph cannot see.

The argument is straightforward. When an agent answers a question, the legitimacy of the answer depends on two things: what data fed it, and whether the agent was entitled to read that data. Standard lineage answers the first question. It does not answer the second. An auditor examining the graph can see that a revenue figure derived from a customer table, but cannot see whether the agent's identity was authorized to read that table, whether the read was within a delegated user scope, or whether the scope had been narrowed since the agent was configured.

Recording scope on the lineage record closes that gap. The design considerations are:

  • Agent identity as a first-class principal. The agent should have its own identity, distinct from any human user, so that reads can be attributed to it and its permissions can be reviewed like any other service account.

  • Least-privilege scope, recorded per run. The scope in force at the time of the run should be captured, not the scope the agent holds today. If the agent's permissions are later broadened or narrowed, the historical record should still show what was permitted when the answer was produced.

  • Delegation made explicit. Where the agent acts on behalf of a requesting user, the record should distinguish the agent's identity from the delegated user context, and show which scope governed each read.

A related failure mode is worth naming because it is easy to miss. Lineage-based tag propagation — the mechanism by which classifications such as sensitivity or handling restrictions follow data as it is copied, transformed, or embedded into derived assets — can drift. Practitioner guidance on the topic describes the failure as governance drift: sensitive content loses its classification as it moves into reports, extracts, backups, caches, or analytics products, which makes access decisions inconsistent and hides exposure from reviewers. The reverse problem also occurs, where tags propagate too broadly and block legitimate use of data that no longer carries the same risk.

Agents amplify both directions. An agent that caches a query result, embeds retrieved rows in a prompt, or writes a derived table creates new assets at machine speed. If classification does not follow those assets, the authorization scope recorded on the run will describe a read that was permitted against a source that was correctly labeled, while the derived copy sits unlabeled somewhere else. Access-aware lineage and tag propagation are therefore complementary controls: the first records who was allowed to read what, the second keeps the labels that make the permission meaningful as data moves.

When a Metric Definition Changes: Propagating Impact to Agent Outputs

Metric definitions change. A margin calculation is revised, a revenue definition is narrowed to exclude a category, a churn window moves from 30 to 90 days. In a dashboard estate, the change-control question is tractable: identify the definition, walk the graph forward to the charts and models that consume it, notify their owners, and re-certify or retire them.

Agent consumers break the tractability in a specific way. Agent outputs are not registered consumers in advance. There is no list of "dashboards that use the margin metric" equivalent for agent answers, because the answers were generated on demand and, in most estates today, were never recorded as consumers at all. The graph cannot be walked forward from the definition to the affected outputs, because the outputs were never added to the graph.

The remedy is to record runs (as described above) and then query the graph backward. When a definition changes, the question becomes: which recorded runs resolved this definition, at which version, and what did they produce? That query is answerable only if the run record carries the definition identifier and version. It is not answerable from column-level lineage alone, because the definition is a semantic artifact, not a physical column.

Impact classification should distinguish two cases:

  • Query-time resolution. The agent resolved the definition live at the moment of the run. A definition change affects future runs immediately and past runs not at all — the past answers used the version in force then, which the run record shows.

  • Cached resolution. The agent or an intermediate layer cached the definition or a result computed from it. A definition change may leave cached answers stale, and the affected runs are those whose cache entries predate the change. These are the runs that need review.

Practitioner guidance follows from this. Gate definition changes behind an impact review that explicitly includes agent consumers, and make the review's first step a backward query over recorded runs rather than a forward walk over registered assets. Where the run record does not carry definition versions, that step cannot be completed, and the honest conclusion is that the impact of the change on agent outputs is unknown — which is itself a finding worth escalating.

Reconstructing an Answer as of a Point in Time

Reconstructing an agent's answer for audit means establishing what the agent could have read and how it was defined at the moment of the run. It does not mean regenerating the identical text.

The data-state half of the problem is well understood. Apache Iceberg's specification resolves point-in-time queries through the snapshot-log, a list of timestamp and snapshot ID pairs recording changes to the table's current snapshot. A query such as SELECT * FROM prod.db.table TIMESTAMP AS OF '...' finds the snapshot just prior to the given timestamp in the snapshot log and scans using that snapshot's metadata. The spec is explicit that if no snapshot exists prior to the timestamp, or if the snapshot log is not populated, systems should raise an informative error about the missing metadata. Bitemporal practice more generally separates valid time from transaction time, which is what allows a system to answer both "what was true then" and "what did we believe then."

Extending this to the agent layer requires four things to be resolvable at the recorded timestamp:

  1. The table snapshot for each input dataset, resolved through the snapshot log or an equivalent mechanism.

  2. The metric definition version in force, taken from the run record.

  3. The agent's configuration and model version — prompt templates, tool definitions, retrieval settings, and the model identifier.

  4. The recorded run itself, including the question, the tool path, and the scope.

With all four, an auditor can reconstruct the input state and the definitional context. What this does not guarantee is an identical generated answer. Language models are not deterministic in general, and even where sampling is controlled, the reconstruction establishes what the agent could have read and how the question was defined — not that the same tokens would be emitted. That distinction is the auditable claim, and it is the one that matters for a complaint, an internal review, or a supervisory conversation. "Here is the data the agent read, the definition it applied, and the scope it acted under" is a defensible statement. "Here is a bit-identical reproduction of the answer" is not a claim most systems can make.

The retention boundary deserves explicit treatment. Iceberg's snapshot expiration procedure removes snapshots from table metadata and applies the table's retention policy; when snapshots are expired, entries before an expired snapshot are removed from the snapshot log. The practical consequence is that the horizon for reconstructing an answer is the shortest of: the table's snapshot retention, the lineage graph's run retention, and the retention of the agent configuration and model version records. If any one of those is shorter than your audit obligation, reconstruction fails at that boundary. Setting these policies independently, without comparing them, is a common and quiet way to lose auditability.

What the Rules Actually Require — and What They Don't

This is the section where overstatement is easiest and most damaging, so it is worth stating precisely what the rules say and what they do not.

AI Act application dates, months after 2 August 2026 General date of application is 2 August 2026 (month 0). High-risk obligations for Article 6(2)/Annex III systems apply from 2 December 2027 (month 16). High-risk obligations for Article 6(1)/Annex I systems apply from 2 August 2028 (month 24). Values are months elapsed from the general application date. AI Act application dates, months after 2 August 2026. horizontal bar data: General application (2 Aug 2026) 0; Annex III high-risk (2 Dec 2027) 16; Annex I high-risk (2 Aug 2028) 24.Source: EU AI Act Service Desk, Article 113: Entry into force and application consolidated text as at 27 July 2026. AI Act application dates,months after 2 August 2026 Generalapplication (2Aug 2026) 0 Annex IIIhigh-risk (2 Dec2027) 16 Annex Ihigh-risk (2 Aug2028) 24 Source: EU AI Act Service Desk, Article 113: Entryinto force and application (consolidated text as at27 July 2026)

Application dates under Article 113 as amended by the Digital Omnibus on AI (Regulation (EU) 2026/1744). Article 12 sits in Chapter III Section 1, whose obligations the Commission's service desk describes as delayed; the Service Desk page does not state Article 12's own application date directly. Bars show months from the 2 August 2026 general application date, not elapsed regulatory effect.

EU AI Act, Article 12. High-risk AI systems must technically allow for the automatic recording of events (logs) over the lifetime of the system. The purpose is to ensure a level of traceability of the system's functioning appropriate to its intended purpose, including the specific context and conditions of use. For remote biometric identification systems, the Article specifies particular log contents. For high-risk systems generally, the obligation is logging capability and traceability, not a prescribed schema for consumer-level lineage.

EU AI Act, Article 19. Providers of high-risk AI systems must keep the logs referred to in Article 12(1), to the extent those logs are under their control, for a period appropriate to the system's intended purpose and of at least six months, unless applicable Union or national law — in particular Union law on the protection of personal data — provides otherwise. Financial institutions must maintain these logs as part of their internal governance documentation under EU financial services law.

EU AI Act, Article 86. Affected persons subject to certain deployer decisions based on the output of an Annex III high-risk system have a right to obtain clear and meaningful explanations of the AI system's role in the decision-making procedure and the main elements of the decision. The right is subject to exceptions and to the proviso that it applies only to the extent it is not otherwise provided under Union law. Per Article 113, it comes into force on 2 August 2026.

Application dates. Article 113 sets 2 August 2026 as the general date of application, with a later date — 2 December 2027 — for AI systems classified as high-risk pursuant to Article 6(2) and Annex III. The Digital Omnibus on AI (Regulation (EU) 2026/1744) amended the Act and, as the Commission's service desk notes, delayed the high-risk obligations in Chapter III Sections 1–3 because of delayed standards, common specifications, and the establishment of national competent authorities. Anyone planning against these dates should read the consolidated text rather than an original-version summary.

The honest limit. These provisions require logging and traceability for high-risk systems. They do not name non-human consumers as a category, and they do not prescribe that an agent's answer be traceable to a metric definition version or an authorization scope. The requirement is traceability appropriate to intended purpose. Whether consumer-level lineage satisfies that requirement for a given system is a judgment a deployer or provider has to make and document; it is not a checklist item the Act supplies.

On the financial side, the revised interagency model risk guidance issued 17 April 2026 (SR 26-2, superseding SR 11-7 and SR 21-8) states plainly that generative AI and agentic AI models are novel and rapidly evolving and are not within the scope of the guidance, while noting that a banking organization's risk management and governance practices should guide the determination of appropriate governance and controls for tools not covered. The guidance also states that it does not set forth enforceable standards or prescriptive requirements. It therefore does not by itself require traceability to agent outputs — and it does not forbid it either. It leaves the question to the organization's own governance.

The conclusion is uncomfortable but accurate: the regulatory case for consumer-level lineage is currently built from general traceability and governance principles, not from a rule that says "trace the agent." That does not make the practice optional in a well-run estate. It means the justification is risk management and auditability, and the specific design is yours to defend.

Questions to Put to a Platform Vendor

The following are criteria, not a scorecard, and they are framed as questions because a vendor's answer — including a deflection — is more informative than a feature list. For each group, a passing answer is specific and demonstrable; a deflection is general and deferred.

Graph coverage. Does lineage capture agent runs as first-class consumers, or only tables and dashboards? Passing: the vendor can show a recorded agent invocation in the graph, with its inputs, alongside the table and dashboard lineage. Deflection: "our lineage covers the whole estate" without demonstrating an agent run as a node.

Record completeness. Can a single answer be traced to its metric definition version, the input columns actually read, and a run identifier? Passing: a live trace from one answer to those three records. Deflection: column-level lineage demonstrated without the definition version or the run ID.

Access awareness. Is authorization scope recorded on the lineage record, and can it be queried? Passing: a query that returns the scope in force for a given run, distinguishable from the agent's current permissions. Deflection: "access is enforced by the policy engine" — which answers a different question.

Point-in-time reconstruction. What is the retention horizon, and can a past answer's inputs be resolved? Passing: a stated horizon, a demonstration of resolving a past run's inputs, and an explanation of what happens at the boundary. Deflection: time travel demonstrated on a table without connecting it to the run record.

Change impact. Can the platform walk from a definition change to affected agent runs? Passing: a backward query over recorded runs returning the runs that resolved the prior version. Deflection: forward lineage from the definition to registered dashboards only.

Interface parity. Does the same graph serve human and agent consumers, or are there two pictures that drift? Passing: one graph, queried through both a human interface and a machine interface, with the same underlying records. Deflection: a separate "AI observability" view that is not reconciled with the catalog.

Two closing questions are worth adding. First: what does the platform record when the agent reads data through a tool that is not a SQL query — an API call, a retrieval step, a file read? Second: what happens to the lineage record when the agent's output is itself consumed by another agent? The second question is where most current designs have no answer, and asking it early tells you whether the vendor has thought about chains.

Conclusion

Lineage that ends at the dashboard was scoped to a consumer that no longer describes the estate. The dashboard was a convenient terminal artifact: enumerable, stable, owned. The agent is none of those things, and treating it as an edge case produces a graph with a dangling end exactly where the most consequential answers are being generated.

The shift required is not more lineage but a different lineage record. The agent is a consumer, and the graph must record its run, its scope, its definition, and its time anchor. Record the run so the invocation exists as an object rather than a memory. Record the scope so an auditor can see not only what data fed the answer but whether the read was permitted. Record the definition so a change to a metric can be traced to the answers it affects. Record the time anchor so a past answer can be reconstructed to the limit of retention — and know what that limit is.

None of this is mandated by a rule that says "trace the agent." The EU AI Act requires logging and traceability for high-risk systems; the revised interagency model risk guidance explicitly excludes generative and agentic AI from its scope. The case rests on governance and auditability, which is a weaker mandate on paper and a stronger one in practice, because the first serious question about an agent's answer will arrive before any regulator asks it.

The practical starting point is small. Pick one agent query. Ask whether your current graph can answer, for that single query: which definition version was resolved, which columns were read, under what scope, against which snapshot, and when. If the answer is no — and for most estates today it is — you have found the boundary, and you know what to ask vendors next.

Frequently Asked Questions

Doesn't existing column-level lineage already cover what an agent reads?

No. Column-level lineage covers the data path: which columns fed which downstream columns. It does not carry the consumer instance. The records it lacks are the run identifier, the resolved metric definition version, and the authorization scope under which the read occurred. Those are properties of an invocation, not of a column, and no column-level edge can express them.

If we can't reproduce the exact generated answer, is point-in-time reconstruction worth doing?

Yes, because the auditable claim is not textual identity. Reconstruction establishes what data the agent could have read, which definition it applied, and what scope it acted under. That is the claim an auditor, a reviewer, or a supervisor needs. Output reproduction is a different and generally unattainable goal; conflating the two leads teams to abandon reconstruction because they cannot achieve reproduction.

Our model risk framework already documents models. Isn't that enough?

Model documentation describes the model: its purpose, methodology, assumptions, and validation. Consumer-level lineage describes each invocation and its inputs. They answer different questions. Note also that the revised interagency guidance (SR 26-2) explicitly excludes generative and agentic AI from its scope, so it neither requires nor settles the question of invocation-level traceability for agents.

Does the EU AI Act require us to trace agent outputs?

Not in those terms. Article 12 requires high-risk AI systems to allow automatic logging over their lifetime, with traceability appropriate to intended purpose. Article 19 sets a retention expectation of at least six months, or as required by applicable law. The Act does not name non-human consumers as a category and does not prescribe an agent-lineage schema. Whether consumer-level lineage is how you satisfy the traceability obligation for a given system is a determination you make and document.

We use a natural-language query tool, not an autonomous agent. Does this apply?

The same gap appears whenever a tool generates an answer per query rather than serving a fixed chart. The run-level record and the resolved definition version matter for natural-language query tools too, even where no autonomous action is taken. The difference is one of degree — an autonomous agent that acts on its output raises the stakes — not of kind.