Blog

Beyond Static Dashboards: How to Architect LookML for Conversational AI & Data Agents

Reading time.

13 mins

Wrtitten by

Virginia García-Martín

Business Intelligence

Analytics Engineering

Artificial Intelligence

The Shift to Conversational Analytics

Dashboards are excellent at answering questions we already know to ask. Analytics engineers define the metrics, dimensions, and visualizations; business users monitor them and investigate changes.

But the next question often falls outside the dashboard. Answering it can mean an ad hoc analysis, a new visualization, or another report. That workflow is familiar, but it also creates bottlenecks between the people asking questions and the people modeling the data.

Conversational Analytics (powered by Gemini) offers a new perspective: users ask questions in natural language, and Looker translates them into queries and visualizations grounded in the semantic model. The important architectural choice is not that an LLM can generate an answer. It’s that the answer can be built on the same governed definitions we use elsewhere in Looker.


End-to-end architecture of a Conversational Analytics query in Looker.

That distinction matters. A semantic layer gives the agent structure; it doesn’t guarantee accuracy. Field selection, filters, joins, and generated explanations still need to be tested. Our job is to make the model understandable enough for conversational use while keeping security and shared business logic outside the prompt.

Explore or Data Agent?

There are two setup modes that can be used for conversational analytics: Explore Mode and Data Agent Mode.

Press enter or click to view image in full size


Architectural decision tree for choosing between direct Explore Mode and a configured Data Agent.

Explore Mode


  • Directly querying an Explore with zero upfront agent configuration.

  • Works well when users already know the semantic layer naming conventions and the Explore is optimized and clean.

Agent Mode


  • Creating a specialized agent configured for a specific domain.

  • Connects up to 5 Explores.

  • It’s best for non-technical business users who dominates business terminology rather than database terminology.

  • Allows custom behavioral system prompts, terminology mapping, custom calculations, and mandatory filters.

Press enter or click to view image in full size


Comparison Matrix

So, when to use each?

The choice isn’t a substitute for modeling work. In either case, the Explore needs accurate definitions, appropriate access controls, and fields that correspond to the questions users will ask.

Use an explore directly if your explore is powered by an optimized, robust, clean and organized semantic layer; the questions are typically straightforward asked, so they map directly to the existing fields in the Explore; you don’t need specific context beyond LookML semantic’s layer; or if you match all of the requirements you definitely should use an Explore to ask your business questions.

Create a Data Agent in Looker if you need specific context, or the questions are not straightforward asked nor the users don’t fully understand the terminology and structure of the Explore.

You are in charge of providing additional context and instructions, the agent will elaborate more complex answers and business insights.

Divide responsibility between LookML and the agent

A common mistake in conversational BI is placing security rules or foundational business logic into the agent’s intructions. Prompts can guide behavior, but it is not a reliable enforcement boundary.

In order to get the desired results, you need to establish a strict governance architecture so developers don’t misplace logic.

Put shared definitions and hard controls in LookML


  • Row-Level Security (RLS): Apply Looker Access Filters and user attributes or create the logic already in your data warehouse, before Looker models consume the data. Never rely on a prompt to secure data.

  • Metric Logic (Single Source of Truth): Define shared calculations in your semantic layer, never compute primary formulas in prompt instructions. If the metric calculation changes, it should only change in LookML.

  • Field-specific context: Put stable labels, descriptions and 1-to-1 Synonyms in LookML.

Use agent instructions for conversational context

Agent instructions are useful for domain-specific terminology, response style, and defaults for underspecified questions. For example:

  • Explain that this agent supports commercial analysis rather than HR questions.

  • Map a business phrase to an existing combination of fields when that context is specific to the agent.

  • Suggest a default time range when the user hasn’t provided one, while allowing an explicit request to override it.

If a definition such as “high-value customer” must be consistent across reports and users, model it as a governed field rather than relying only on an agent instruction. Similarly, a prompt asking the agent to decline certain topics is a conversational boundary, not an access control.

Google’s guidance makes the same distinction: context that should apply across uses belongs in LookML; agent instructions are better suited to the user’s role, goals, and conversational behavior.

Prime the semantic layer for AI

Building a consistent semantic layer is fundamental to prevent agent confusion and hallucinations.

Curate “Lightweight Explores” with extends

A dedicated Explore lets you reuse an existing model while exposing a smaller set of business-relevant fields (Lightweight Explore):

# Production Lightweight Explore for Conversational AIexplore: orders_conversational {  extends: [orders_base]  label: "Orders & Sales (Conversational)"  description: "Curated model containing core customer,   order, and revenue KPIs for natural language questions."    # Whitelist only verified, business-critical fields  fields: [  orders.order_id,  orders.status,  orders.total_net_revenue,  orders.order_count,  orders.average_order_value,  orders.created_date,  customers.customer_tier,  customers.country_name,  customers.acquisition_channel  ]}
# Production Lightweight Explore for Conversational AIexplore: orders_conversational {  extends: [orders_base]  label: "Orders & Sales (Conversational)"  description: "Curated model containing core customer,   order, and revenue KPIs for natural language questions."    # Whitelist only verified, business-critical fields  fields: [  orders.order_id,  orders.status,  orders.total_net_revenue,  orders.order_count,  orders.average_order_value,  orders.created_date,  customers.customer_tier,  customers.country_name,  customers.acquisition_channel  ]}
# Production Lightweight Explore for Conversational AIexplore: orders_conversational {  extends: [orders_base]  label: "Orders & Sales (Conversational)"  description: "Curated model containing core customer,   order, and revenue KPIs for natural language questions."    # Whitelist only verified, business-critical fields  fields: [  orders.order_id,  orders.status,  orders.total_net_revenue,  orders.order_count,  orders.average_order_value,  orders.created_date,  customers.customer_tier,  customers.country_name,  customers.acquisition_channel  ]}

This is an illustrative pattern: the fields must exist in your model, and you should validate the extended Explore before deploying it. Looker supports using extends with an Explore-level fields list to limit the exposed fields. ⁠Here’s what you should do to configure these explores:

  • Include only the curated subset of essential KPIs and dimensions.

  • The goal is not to remove every technical detail. It’s to expose fields that help answer real questions and exclude duplicate metrics, intermediate calculations, or internal identifiers that add noise.

  • Exclude UI-only fields (HTML formatting, custom tooltips, navigation bars) and remove or isolate heavy Period-over-Period (PoP) or parameter-based fields that conversational engines cannot manipulate

  • A field whitelist does not automatically remove inherited joins. Review the base Explore’s joins and generated SQL separately, especially where join dependencies, fanout, or performance are concerns.

Make labels and descriptions earn their place

A field name tells the model what a field is called. A good description explains what it means and when to use it.

dimension: country_iso_code {  label: "Country"  description: "The 2-digit ISO code identifying the store's physical operating country. Use this field for geographic aggregations and regional breakdowns."  type: string  sql: ${TABLE}.country_code ;;}
dimension: country_iso_code {  label: "Country"  description: "The 2-digit ISO code identifying the store's physical operating country. Use this field for geographic aggregations and regional breakdowns."  type: string  sql: ${TABLE}.country_code ;;}
dimension: country_iso_code {  label: "Country"  description: "The 2-digit ISO code identifying the store's physical operating country. Use this field for geographic aggregations and regional breakdowns."  type: string  sql: ${TABLE}.country_code ;;}

Descriptions are particularly useful when two metrics sound similar. If both sales_amount and total_sales_value are exposed, explain the difference in grain, included transactions, tax treatment, and currency; or remove one if it has no distinct analytical purpose.

Don’t assume a description makes an answer correct. It gives the agent better context; you still need to test the questions and resulting queries.

Add native synonyms

Use Looker’s native synonyms for alternative names for a field:

dimension: store_location {  label: "Store"  synonyms: ["shop", "retail outlet"]  description: "The physical retail outlet where the transaction occurred."  type: string  sql: ${TABLE}.shope_name ;;}
dimension: store_location {  label: "Store"  synonyms: ["shop", "retail outlet"]  description: "The physical retail outlet where the transaction occurred."  type: string  sql: ${TABLE}.shope_name ;;}
dimension: store_location {  label: "Store"  synonyms: ["shop", "retail outlet"]  description: "The physical retail outlet where the transaction occurred."  type: string  sql: ${TABLE}.shope_name ;;}

It helps map user language to fields without repeating the same mapping in every agent.

Group related fields

group_label can make an Explore easier for people to navigate in Looker:

dimension: shipping_city {  group_label: "Shipping Info"  label: "Shipping City"  description: "City associated with the primary shipping destination."  type: string  sql: ${TABLE}.shipping_city ;;}  dimension: shipping_carrier {  group_label: "Shipping Info"  label: "Shipping Carrier"  description: "Logistics provider handling fulfillment (e.g., DHL, FedEx)."  type: string  sql: ${TABLE}.carrier ;;}
dimension: shipping_city {  group_label: "Shipping Info"  label: "Shipping City"  description: "City associated with the primary shipping destination."  type: string  sql: ${TABLE}.shipping_city ;;}  dimension: shipping_carrier {  group_label: "Shipping Info"  label: "Shipping Carrier"  description: "Logistics provider handling fulfillment (e.g., DHL, FedEx)."  type: string  sql: ${TABLE}.carrier ;;}
dimension: shipping_city {  group_label: "Shipping Info"  label: "Shipping City"  description: "City associated with the primary shipping destination."  type: string  sql: ${TABLE}.shipping_city ;;}  dimension: shipping_carrier {  group_label: "Shipping Info"  label: "Shipping Carrier"  description: "Logistics provider handling fulfillment (e.g., DHL, FedEx)."  type: string  sql: ${TABLE}.carrier ;;}

Grouping is useful for organizing related fields using group_label: “”(e.g., grouping shipping_city, shipping_state, and shipping_street under “Shipping Info”). It helps the agent understand hierarchical and relational connections among related fields, but it should not replace precise descriptions or correct joins.

Keep the exposed model intentional

A few additional checks matter in production:

  • Use format_name explicitly: Use formats that match the currency, percentage, or unit being reported, and describe units explicitly.

  • Hide technical fields with hidden:yes , not primary business measures: A measure the agent needs must be available in the Explore.

  • Review query cost: Curating fields can reduce selection noise, but it does not by itself prove that warehouse queries will be efficient.

Design the agent configuration around decisions

Moving on the Looker Semantic Layer, the Agent configuration can focus on the conversation: who the agent helps, how it handles ambiguity, and how it presents results.


Modular anatomy of a Looker Data Agent’s instruction block.

Instructions should always answer these questions:

  1. Scope: What business domain does the agent serve?

  2. Interpretation: Which terms or defaults are specific to this audience?

  3. Response: What should the agent show, and when should it ask for clarification?

  4. Boundaries: Which requests are outside the intended use case?

Writing a rule is essential

Keep instructions concise. A longer list of “must-follow” rules can look reassuring, but it is not the same as a tested control. Put requirements that must be enforced in the model or access layer:


Modular anatomy of a Looker Data Agent’s rule block.

  • Triggering conditions: Define the user behavior/question that would “activate” the rule. If it’s a default behavior you want the Agent to take, no need to define a trigger condition.

  • Constrains: Include behaviors that should absolutely not happen when this rule is triggered (Ex: “If the user asks about sales, do not show gross sales data”)

  • Default behavior: Include the default behavior that has to happen when the rule is triggered (Ex: “If the user asks about sales, always display net sales”)

  • Forbidden section: Lists specific actions the agent must never perform under this rule.

  • Required section: Lists mandatory steps the agent must always execute when the rule is triggered.

  • Actions: Defines the internal steps the agent should take to handle the situation correctly.

  • Display section: Specifies exactly what the agent should say or show to the user.

  • Waiting section: Instructs the agent to pause execution and take no further action until the user responds

A Jaffle Shop commercial analyst

The following is an illustrative agent instruction based on the fields in the original draft. It assumes a jaffle_shop Explore with these field names and historical data between 2018 and 2019. Verify the actual model, metric definitions, permissions, and date range before using it.

<system_instructions>You are the Jaffle Shop Commercial & Revenue Analyst Assistant.Your primary role is to answer sales, order volume, store performance, customer LTV, and revenue forecasting questions for Operations and Commercial Managers using the `jaffle_shop` Explore.Communicate concisely, lead directly with the requested metric value, and translate LookML field names into clean business terms (e.g., use "Order Count" instead of "Cnt" and "Order Date" instead of "Order Date Date").</system_instructions><answer_protocol>When processing any inbound prompt:1. Identify the temporal dimension (`jaffle_shop.order_date_date`). Note that Jaffle Shop is a static historical dataset spanning 2018 through 2019 (whereas the current calendar year is 2026). If the user asks for "recent", "current", or "all-time" performance without specifying dates, query the full available 2018–2019 date range rather than filtering to 2026.2. Map business terms to certified LookML measures (`total_revenue`, `cnt`, `total_ltv`, `amount`) rather than summing raw dimensions (`order_total`, `subtotal`, `ltv`).3. Check if any `<rule_block>` constraint applies to the user's request before generating the Looker query.4. Present the primary visualization or metric clearly, followed by a concise 2-sentence executive takeaway.</answer_protocol><constraints>  <rule_block>    IF: User asks about "sales", "revenue", "earnings", or "income" without specifying pre-tax or post-tax.    DEFAULT BEHAVIOR: Query `jaffle_shop.total_revenue` as the primary metric.    FORBIDDEN: Never use the raw `jaffle_shop.order_total` or `jaffle_shop.subtotal` dimensions as aggregated totals when `total_revenue` is available.    REQUIRED: Group by `jaffle_shop.order_date_month` (or `jaffle_shop.order_date_date` truncated appropriately) if a trend is requested.    DISPLAY: Format currency values cleanly and display a line chart for time-series trends or a bar chart for store comparisons.  </rule_block>  <rule_block>    IF: User asks about "orders", "order volume", "transactions", or "number of purchases".    DEFAULT BEHAVIOR: Query `jaffle_shop.cnt` to represent order count.    REQUIRED: Label the metric as "Total Orders" in your final response.    DISPLAY: Present a summary table or bar chart sorted by `jaffle_shop.cnt` descending.  </rule_block>  <rule_block>    IF: User asks about "VIP customers", "high-value customers", "loyalty tiers", or "customer lifetime value (LTV)".    DEFAULT BEHAVIOR: Query `jaffle_shop.tier`, `jaffle_shop.total_ltv`, and `jaffle_shop.cnt`.    FORBIDDEN: Never display raw `jaffle_shop.customer_id` or `jaffle_shop.user_id` lists unless the user explicitly asks for the "top N individual customer IDs".    REQUIRED: Aggregate LTV using the `jaffle_shop.total_ltv` measure rather than the `jaffle_shop.ltv` dimension.    DISPLAY: Show a breakdown by `jaffle_shop.tier` sorted by `jaffle_shop.total_ltv` descending.  </rule_block>  <rule_block>    IF: User asks for a "forecast", "prediction", "projection", or "future revenue/orders".    CONSTRAINT: Standard Looker SQL queries only return historical data; forecasting must be executed via Looker's Advanced Analytics (Python Code Interpreter).    ACTION:     1. Query historical monthly `jaffle_shop.order_date_month` alongside `jaffle_shop.total_revenue` (or `jaffle_shop.cnt`) across the entire 2018–2019 historical dataset.    2. Invoke Advanced Analytics to fit appropriate time-series forecasting models (such as Linear Regression or Holt-Winters Exponential Smoothing) projecting forward into late 2019 and 2020 from the end of the historical series.    3. Generate a time-series chart comparing historical actuals against the projected trajectory.    REQUIRED: Explicitly state the historical date range used to train the forecast (e.g., 2018-09 through 2019-08) and explain the forecasting methodologies applied.    DISPLAY: Output the forecast chart followed by a clean table of projected monthly values and a brief executive takeaway comparing conservative vs. growth trajectories.  </rule_block>  <rule_block>    IF: User asks about product items, food menu items (e.g., jaffles vs. beverages), marketing channels, or employee/HR data.    CONSTRAINT: Out of domain / missing fields in current Explore.    ACTION: Refuse execution politely without guessing or hallucinating fields.    DISPLAY: "The current Jaffle Shop Explore only contains order, revenue, store, and customer tier metrics—product-level and operational data are not available in this view."    WAIT: Stop execution and wait for a new user question.  </rule_block></constraints>
<system_instructions>You are the Jaffle Shop Commercial & Revenue Analyst Assistant.Your primary role is to answer sales, order volume, store performance, customer LTV, and revenue forecasting questions for Operations and Commercial Managers using the `jaffle_shop` Explore.Communicate concisely, lead directly with the requested metric value, and translate LookML field names into clean business terms (e.g., use "Order Count" instead of "Cnt" and "Order Date" instead of "Order Date Date").</system_instructions><answer_protocol>When processing any inbound prompt:1. Identify the temporal dimension (`jaffle_shop.order_date_date`). Note that Jaffle Shop is a static historical dataset spanning 2018 through 2019 (whereas the current calendar year is 2026). If the user asks for "recent", "current", or "all-time" performance without specifying dates, query the full available 2018–2019 date range rather than filtering to 2026.2. Map business terms to certified LookML measures (`total_revenue`, `cnt`, `total_ltv`, `amount`) rather than summing raw dimensions (`order_total`, `subtotal`, `ltv`).3. Check if any `<rule_block>` constraint applies to the user's request before generating the Looker query.4. Present the primary visualization or metric clearly, followed by a concise 2-sentence executive takeaway.</answer_protocol><constraints>  <rule_block>    IF: User asks about "sales", "revenue", "earnings", or "income" without specifying pre-tax or post-tax.    DEFAULT BEHAVIOR: Query `jaffle_shop.total_revenue` as the primary metric.    FORBIDDEN: Never use the raw `jaffle_shop.order_total` or `jaffle_shop.subtotal` dimensions as aggregated totals when `total_revenue` is available.    REQUIRED: Group by `jaffle_shop.order_date_month` (or `jaffle_shop.order_date_date` truncated appropriately) if a trend is requested.    DISPLAY: Format currency values cleanly and display a line chart for time-series trends or a bar chart for store comparisons.  </rule_block>  <rule_block>    IF: User asks about "orders", "order volume", "transactions", or "number of purchases".    DEFAULT BEHAVIOR: Query `jaffle_shop.cnt` to represent order count.    REQUIRED: Label the metric as "Total Orders" in your final response.    DISPLAY: Present a summary table or bar chart sorted by `jaffle_shop.cnt` descending.  </rule_block>  <rule_block>    IF: User asks about "VIP customers", "high-value customers", "loyalty tiers", or "customer lifetime value (LTV)".    DEFAULT BEHAVIOR: Query `jaffle_shop.tier`, `jaffle_shop.total_ltv`, and `jaffle_shop.cnt`.    FORBIDDEN: Never display raw `jaffle_shop.customer_id` or `jaffle_shop.user_id` lists unless the user explicitly asks for the "top N individual customer IDs".    REQUIRED: Aggregate LTV using the `jaffle_shop.total_ltv` measure rather than the `jaffle_shop.ltv` dimension.    DISPLAY: Show a breakdown by `jaffle_shop.tier` sorted by `jaffle_shop.total_ltv` descending.  </rule_block>  <rule_block>    IF: User asks for a "forecast", "prediction", "projection", or "future revenue/orders".    CONSTRAINT: Standard Looker SQL queries only return historical data; forecasting must be executed via Looker's Advanced Analytics (Python Code Interpreter).    ACTION:     1. Query historical monthly `jaffle_shop.order_date_month` alongside `jaffle_shop.total_revenue` (or `jaffle_shop.cnt`) across the entire 2018–2019 historical dataset.    2. Invoke Advanced Analytics to fit appropriate time-series forecasting models (such as Linear Regression or Holt-Winters Exponential Smoothing) projecting forward into late 2019 and 2020 from the end of the historical series.    3. Generate a time-series chart comparing historical actuals against the projected trajectory.    REQUIRED: Explicitly state the historical date range used to train the forecast (e.g., 2018-09 through 2019-08) and explain the forecasting methodologies applied.    DISPLAY: Output the forecast chart followed by a clean table of projected monthly values and a brief executive takeaway comparing conservative vs. growth trajectories.  </rule_block>  <rule_block>    IF: User asks about product items, food menu items (e.g., jaffles vs. beverages), marketing channels, or employee/HR data.    CONSTRAINT: Out of domain / missing fields in current Explore.    ACTION: Refuse execution politely without guessing or hallucinating fields.    DISPLAY: "The current Jaffle Shop Explore only contains order, revenue, store, and customer tier metrics—product-level and operational data are not available in this view."    WAIT: Stop execution and wait for a new user question.  </rule_block></constraints>
<system_instructions>You are the Jaffle Shop Commercial & Revenue Analyst Assistant.Your primary role is to answer sales, order volume, store performance, customer LTV, and revenue forecasting questions for Operations and Commercial Managers using the `jaffle_shop` Explore.Communicate concisely, lead directly with the requested metric value, and translate LookML field names into clean business terms (e.g., use "Order Count" instead of "Cnt" and "Order Date" instead of "Order Date Date").</system_instructions><answer_protocol>When processing any inbound prompt:1. Identify the temporal dimension (`jaffle_shop.order_date_date`). Note that Jaffle Shop is a static historical dataset spanning 2018 through 2019 (whereas the current calendar year is 2026). If the user asks for "recent", "current", or "all-time" performance without specifying dates, query the full available 2018–2019 date range rather than filtering to 2026.2. Map business terms to certified LookML measures (`total_revenue`, `cnt`, `total_ltv`, `amount`) rather than summing raw dimensions (`order_total`, `subtotal`, `ltv`).3. Check if any `<rule_block>` constraint applies to the user's request before generating the Looker query.4. Present the primary visualization or metric clearly, followed by a concise 2-sentence executive takeaway.</answer_protocol><constraints>  <rule_block>    IF: User asks about "sales", "revenue", "earnings", or "income" without specifying pre-tax or post-tax.    DEFAULT BEHAVIOR: Query `jaffle_shop.total_revenue` as the primary metric.    FORBIDDEN: Never use the raw `jaffle_shop.order_total` or `jaffle_shop.subtotal` dimensions as aggregated totals when `total_revenue` is available.    REQUIRED: Group by `jaffle_shop.order_date_month` (or `jaffle_shop.order_date_date` truncated appropriately) if a trend is requested.    DISPLAY: Format currency values cleanly and display a line chart for time-series trends or a bar chart for store comparisons.  </rule_block>  <rule_block>    IF: User asks about "orders", "order volume", "transactions", or "number of purchases".    DEFAULT BEHAVIOR: Query `jaffle_shop.cnt` to represent order count.    REQUIRED: Label the metric as "Total Orders" in your final response.    DISPLAY: Present a summary table or bar chart sorted by `jaffle_shop.cnt` descending.  </rule_block>  <rule_block>    IF: User asks about "VIP customers", "high-value customers", "loyalty tiers", or "customer lifetime value (LTV)".    DEFAULT BEHAVIOR: Query `jaffle_shop.tier`, `jaffle_shop.total_ltv`, and `jaffle_shop.cnt`.    FORBIDDEN: Never display raw `jaffle_shop.customer_id` or `jaffle_shop.user_id` lists unless the user explicitly asks for the "top N individual customer IDs".    REQUIRED: Aggregate LTV using the `jaffle_shop.total_ltv` measure rather than the `jaffle_shop.ltv` dimension.    DISPLAY: Show a breakdown by `jaffle_shop.tier` sorted by `jaffle_shop.total_ltv` descending.  </rule_block>  <rule_block>    IF: User asks for a "forecast", "prediction", "projection", or "future revenue/orders".    CONSTRAINT: Standard Looker SQL queries only return historical data; forecasting must be executed via Looker's Advanced Analytics (Python Code Interpreter).    ACTION:     1. Query historical monthly `jaffle_shop.order_date_month` alongside `jaffle_shop.total_revenue` (or `jaffle_shop.cnt`) across the entire 2018–2019 historical dataset.    2. Invoke Advanced Analytics to fit appropriate time-series forecasting models (such as Linear Regression or Holt-Winters Exponential Smoothing) projecting forward into late 2019 and 2020 from the end of the historical series.    3. Generate a time-series chart comparing historical actuals against the projected trajectory.    REQUIRED: Explicitly state the historical date range used to train the forecast (e.g., 2018-09 through 2019-08) and explain the forecasting methodologies applied.    DISPLAY: Output the forecast chart followed by a clean table of projected monthly values and a brief executive takeaway comparing conservative vs. growth trajectories.  </rule_block>  <rule_block>    IF: User asks about product items, food menu items (e.g., jaffles vs. beverages), marketing channels, or employee/HR data.    CONSTRAINT: Out of domain / missing fields in current Explore.    ACTION: Refuse execution politely without guessing or hallucinating fields.    DISPLAY: "The current Jaffle Shop Explore only contains order, revenue, store, and customer tier metrics—product-level and operational data are not available in this view."    WAIT: Stop execution and wait for a new user question.  </rule_block></constraints>

Those are modeling questions. In particular, check whether customer-level values are duplicated by order-level joins before trusting a customer-value breakdown.

Add verified queries separately

You can provide golden questions and answers for your data agent. “Golden Queries” are useful examples of questions to test. In Looker, verified queries pair a natural-language question with a corresponding Explore query. They are configured separately on an Explore data agent. ⁠

Advanced Analytics: Python and forecasting

Standard Looker queries are well suited to governed retrieval and aggregation, but it can be a fundamental limitation when we think of advanced statistical modeling.

Advanced Analytics extends an Explore data agent with Python-based analysis for tasks such as forecasting and more complex visualizations. It is available for data agents, not direct chats with an Explore.


Advanced Analytics experimental capability activated

Enable the feature

A Looker Administrator (roles/looker.admin) must enable the Gemini and Conversational Analytics settings in your Looker instance:

  1. In the Admin panel, navigate to the Platform section and select the Gemini in Looker page.

  2. Under Gemini in Looker enablement, turn on the Enable Gemini in Looker setting.

  3. Under Conversational Analytics, turn on the Conversational Analytics (Conversations page) setting (for Explores) or the Dashboard agents setting (for dashboards), or both.

  4. Under Additional options, turn on the Advanced Analytics setting. When this setting is enabled, data agent creators can choose to enable Advanced Analytics for all conversations with their data agents.


Additional Options: Enabling Advanced Analytics functionality

The Gemini enablement step differs between Looker (original) and Looker (Google Cloud core), so follow the instructions for your deployment rather than assuming the same path for both: Enable and use Advanced Analytics.

How Looker Executes Python Under the Hood

The agent can query the Explore for the historical series and use Advanced Analytics to perform Python-based analysis. Supported libraries include pandas, numpy, and statsmodels. The generated output still needs review: the method must fit the amount and quality of available data, and a plausible chart is not evidence that a forecast is reliable. ⁠

⁠For a static historical dataset, “next six months” means six months after the final observation, not six months after today. If the last complete month is in 2019, the projection begins after that month. State the actual training window and check for incomplete months, gaps, seasonality, and sufficient history before comparing models.

The original draft describes a projection into February 2020. That should be presented as an observed result only after the dataset, last observation, prompt, and resulting chart have been verified.

Because Advanced Analytics is still an experimental capability, Looker executes the Python script in the background and does not explicitly display the generated Python source code in the chat.

Jaffle Shop in Action: Forecasting Made Easy

Let’s see how this works with the Jaffle Shop data agent. There’s one important detail: this example uses a static historical dataset. The forecast starts after the last month of available data, not from the current date.

For example, if the last complete month in the dataset is August 2019, a six-month forecast will project from September 2019 through February 2020. This makes the example useful for illustrating the workflow, but it should not be interpreted as a forecast of current business performance.

Now, let’s ask the agent:
“Pull monthly Total Revenue across all historical dates, then use Python to run a linear regression and Holt-Winters exponential smoothing forecast for the next 6 months. Plot both forecasts against historical actuals.”

Press enter or click to view image in full size


User prompt

If the rules are well-defined, the Agent should be capable of producing a visualization and explanation including the Python-based forecasting:

Press enter or click to view image in full size


Press enter or click to view image in full size


Press enter or click to view image in full size


The Jaffle Shop Agent pulls 2018–2019 historical actuals and renders a 6-month projection extending into February 2020 comparing Linear Regression against Holt-Winters Exponential Smoothing

The BI takeaway

Conversational Analytics should never replace dashboards or the Looker Semantic Layer, it should always amplify them.

Press enter or click to view image in full size


The evolving role of Business Intelligence: Shifting from manual dashboard development to governed semantic graphs and AI guardrails

When we connect conversational interfaces to curated Explores, we give users another way to investigate governed data. But the interface also exposes weaknesses that a dashboard can hide: ambiguous field names, inconsistent metrics, unclear grain, and joins that don’t support the question being asked.

The work for analytics engineers is therefore both familiar and evolving. We still need correct models and enforceable access controls. We also need to make those models legible to a conversational system, test the questions users actually ask, and treat agent instructions as a layer of guidance; not as a substitute for governance.

Ready to bring Conversational Analytics to your Looker instance?
Astrafy helps teams prepare their semantic layer, configure data agents and roll out AI-powered analytics with the right governance in place. Talk to our team



Written by

Virginia García-Martín

Data Analyst & BI Engineer

Catching up

Turn your scattered data & AI initiatives into a coherent strategy

Turn your scattered data & AI initiatives into a coherent strategy

Turn your scattered data & AI initiatives into a coherent strategy