IDEXX QueryLab Dx introduces a new approach to expanding access to analytics by transforming natural-language questions into fully deployable analytical workflows within JMP. Rather than limiting AI to query assistance, this system extends the pipeline from intent to execution – generating governed SQL from structured data artifacts and automatically producing JMP Scripting Language (JSL) wrappers for direct deployment to JMP Live.

The system uses a staged, artifact-driven methodology that aligns user intent with enterprise data schemas, ensuring queries are accurate, explainable, and consistent with governance standards. Generated SQL is validated against predefined rules before being translated into JSL, creating a seamless bridge between data access and interactive analytics.

This approach addresses a common organizational challenge: analytics capabilities are often constrained by technical barriers, such as SQL and scripting expertise. By combining natural language interfaces, governed data access, and automated JSL generation, QueryLab Dx enables broader participation in analytics while preserving the rigor required in enterprise environments.

The presentation demonstrates an interactive JMP workflow, showing how users can generate, inspect, and deploy analytical outputs directly from natural-language input. It also highlights design patterns (such as schema-aware query generation, validation layers, and code synthesis), illustrating how AI can move beyond assistance to enable scalable, trustworthy analytic workflows across multidisciplinary teams.

 

 

Welcome back. My name is Chris Pillsbury, and I'm an R&D Data Solutions Architect at IDEXX Laboratories. Last year, I showed you the cloud data architecture I built to support our JMP and JMP Live users. This year is the follow-up, and it is aimed squarely at you as the scientist. If your data lives in a data system, then the AI agent I built, QueryLab Dx, is there to help you. At the end of this presentation, my hope is that you understand how you can get to governed, trustworthy, continually refreshing data without ever learning databases, SQL, or connectors. Not a lighter version of those skills. None of them.

To see why that matters, let's go back to where we left off last year. Last year, I built a fully automated ecosystem. Raw instrument and lab data is automatically moved to our cloud AWS storage. It shaped and validated Snowflake data models, which are accessible by JMP and JMP Live, and that was a real win. Data that used to be hand-carried in flash drives now arrives on its own in a database. But I want to be honest about what I could not solve until now. If a scientist wanted a new data set, one that I had not delivered to JMP Live yet, they still had only two options: file a request and wait for me, or roll up their sleeves and build their own connection on their own laptop.

Unfortunately, my attempts to train folks on how to do that were blocked by issues on their laptop that often required assistance from the IT help desk. Today, I solve that last step, remove that pain, and hand a new tool to the scientists. We have a full session today, six stops in 40 minutes.

First, the scientist's reality, why the gap between you and your data opened, and what it costs you. Second, where your data actually lives, a plain language picture of the data system. Third, two architectures, which is the heart of the talk. Whether the connector lives on your laptop or on the server decides who does the work. We open the box on QueryLab Dx, then from question to live report, the SQL, the JSL wrapper, and JMP Live 19.5. We close with governance and concrete takeaways you can take back to your own work and make progress.

But before we go any further, let's see what this looks like in practice. Before we talk about how the solution works, let's look at what the solution does. Here in this video, I'm asking the agent for heartworm positive samples from a specific location and within a date range. The agent then passes that prompt through a series of gates to resolve and generates SQL to address that request. While the agent is working, let me get the new data table set up and ready for the code. This is done by clicking the plus sign and selecting Data Table, naming it and adding in a description if you want, and then selecting Refresh Data via Script.

Just as soon as that's done, the agent responds and provides me with a summary of what it resolved from the original prompt, and requires me to accept that or change it before any SQL can be emitted. In my response, I approve the scope and make a request to have the code given to me for deployment in our JMP Live. The agent then passes that through a final gate and produces the SQL in a JMP Live compatible JSL wrapper. That code is then copy-pasted into JMP Live, and the data is refreshed, and after a short period, the table is produced from the SQL query.

This additional functionality, provided in JMP Live 19.5, gives us the option to deploy code directly in JMP Live, bypassing the client altogether. Let's get into it.

Data is the loop every one of you lives in, whether you know it or not. Science is iterative, data generation is dynamic, and data access is neither. Every follow-up question restarts the whole data request cycle in an ever-changing environment that's hard to get to. Let's spend some time on that.

Before I outline these, I want to explain where they came from, because this is not a story about anybody being underqualified. In less than a decade, the data you were used to analyzing moved. It used to be a file on an instrument PC or a shared drive, something you could open and extract files. Now it lives in a cloud warehouse behind an ODBC driver, a credential, and a VPN. The data got better, but reaching it got harder. This gap was never closed. It only concentrated the technical work by landing it on whoever could reach across the gap.

Once it lands on one person, that person's capacity becomes everyone else's ceiling. Every request queues behind one calendar. This is not just an IDEXX problem. If your company moved to a cloud warehouse, you opened the same gap. There is almost certainly one of your colleagues that people go to when they need data. The gap did not open because scientists stopped learning. It opened because the system moved faster than anyone could follow, and that gap continues to grow. It's nobody's fault, and yet it is still everyone's problem.

Let's name what that gap costs you, item by item. SQL isn't your native language, and learning it is a second career that nobody gave you time to start. ODBCs, connectors, drivers, and credentials on your laptop, this is a stack that breaks when IT pushes an update, when your password rotates, or when you get a new machine. Databases are unfamiliar and vast, and finding the right view comes second to making sure you even have access to the view you need. When a well-intentioned upstream IT team makes a change on the source system, a renamed column, a decode value, that shows up in the report as a number that suddenly looks wrong, and you're left to figure out why.

Instrument files were built for the instrument, and parsing raw machine output into something usable is hours of work before the science starts. The clock never stops. You have to make a decision now, today, to batch this lot. Every hour of data wrangling is an hour taken directly out of the science.

There are six frustrations on this slide, and if you're lucky, you can at least get the machine data parsed, albeit painfully. The rest boil down to these actual barriers: the connection and the database knowledge. The connector stack is what physically stops you from reaching the data, and the schema is what stops you from knowing what to ask for. These frustrations are what we call self-service.

Here's what the scientist actually wants: ask a question in plain language, get trustworthy governance SQL back, see it refresh on its own, and spend the saved time on the science. Four things, and none of them mention navigating 15 different Snowflake database schemas.

Here's what today's self-service asks of you in exchange: install and maintain ODBC drivers, store database credentials on your laptop, learn the schema and write SQL, build a client-side data table, then publish it up to JMP Live, and personally own the refresh from then on. That's five infrastructure jobs bolted onto a scientist's job description. We handed people a toolkit and called it empowerment. Self-service should mean the service does more, not that you do more. If the only way to serve yourself is to become a part-time data engineer, that isn't self-service, it's delegation of unfunded work.

But before I show you the fix, I want to fix something else first: the fact that nobody ever explained the data system to you. Historically, the data you generated lived wherever it landed, an export folder on the instrument PC or a shared drive. Today, that same data may be moved into a cloud data system, captured on a schedule and not something you have access to. Once you had the data, you cleaned it with the filters and fixes you did from memory that nobody else can reproduce.

In the data system, that work happens for each data file that gets ingested and is cleaned and ready to analyze automatically. When you needed data, you grabbed the flash drive. Now in the data system, you have to write some SQL code to get the precise slice you asked for and nothing else. Here's the point, and it's the thesis of the whole talk: you already know where your data comes from. You generated it. But where it goes seems like a corn maze. What you never had is a managed, governed access point to the data system and a plain language way to ask for your data back. That's what JMP Live 19.5 and generative AI provides.

Now, there's one decision that changes everything about your data access, and it's a decision most people never realized was made: where does the data connector live? Because where the connector lives decides who does the work. This is the single most important sentence in this talk. If you remember nothing else, remember this one.

Now, let's take a look at the two architectures one at a time, starting with the one most of you are living in today. This is the traditional model, and it works as long as one very specific machine is healthy: yours. Your laptop holds the JMP desktop client. On that laptop, you install an ODBC driver, define a DSN, and store your database credentials. You connect over VPN, you run the query, and JMP builds the data table that lives on your computer. When you want current numbers, you repeat the process. When you want colleagues to see it, you share it or you publish it to JMP Live. But that means you have to connect, authenticate, query, refresh, and publish. Every one of them is a place where your afternoon can disappear.

It's fragile. These are the things that break it: password rotation, a new laptop, a loaner laptop, vacation, leaving the company. Usually, nobody notices until the number on someone's dashboard is 3 months stale because the author moved to a new department. Now, watch what happens when we move exactly one thing: the connector, off your laptop and onto the server. A browser. That's it. That's the whole story of this slide. Same Snowflake, same report, one difference: everything in the middle moved to the JMP Live server.

The server holds a governed connector backed by a service account and runs the refresh on a schedule. The report and dashboard automatically update and are accessible at a URL you can share with any JMP Live user. Your laptop, you open a link in a web browser. No ODBC, no DSN, no credentials on your laptop. The data refreshes whether your laptop is on or off, whether you're at the bench, on a plane, or on vacation, whether you even still work there. That's the last point that matters more than it sounds. Continuity is a governance property. When the plumbing belongs to the server, institutional knowledge stops walking out the door with individuals.

Now, let me put those two models side by side so the trade is unmistakable. One difference drives this whole table: where the connector lives. Everything below is a consequence of row one. The credentials, they're yours to manage them, or you borrow the server's access. On the desktop, you install and keep the ODBC and DSN working. In JMP Live, there's nothing for you to manage but your contributions. The desktop refresh is manual, and it only happens if your laptop is on. JMP Live is scheduled and refreshes on its own.

Now, this turns a tooling preference into a business risk. If you're out or if you leave, the desktop report goes stale and quietly, and usually, nobody notices until someone makes a decision on an old number. For JMP Live, it keeps running until someone stops it. In the last row is the real point: desktop means you manage the whole pipeline, JMP Live means you manage just the question. The question is why the system was built in the first place. How bad is it right now? In my experience, managing the laptop-side connection is the single biggest blocker standing between a scientist and their data. Not the SQL, the connection.

Start with what it actually asks of you. An ODBC driver needs administrator rights on your machine, rights most scientists do not have. The driver is version-locked to a database, so someone has to tell you the right one to use. Then the part that really ends adoption: when the connection breaks, there is no diagnostic step available to you. You file a ticket and you wait. The analysis you were doing this morning is now next week's problem. It never stops costing. A credential to store and rotate, a refresh nobody babysits, per laptop, per new machine, per password rotation, indefinitely.

Say your group is 5, 20, or, like me, 300 people large. Multiply managing those three recurring costs, driver, credential, refresh, by every person who needs data, against one connection and one service account set up once on the server. That is the reason laptop data pipelines never scaled, and it's why "just give everyone access" was never actually the answer. The required skills simply were not there to support it. To be clear, this barrier is mine, too. Same drivers, same version locks, same breakage on every connection I maintain to deliver data to somebody else. How does JMP Live help?

Two things shipped recently that make server-side model practical rather than aspirational. To be honest, none of this was practical even 4 months ago. First, the REST-based Snowflake connector, new in JMP 19.1. It's faster than ODBC, and it was designed for server-side use. Second, and this is the one that unlocks the whole talk, server-side scripted refresh isn't new. JMP Live was built to do that. What JMP 19.5 added is the ability to create a new data table server-side without publishing it from the desktop first. That means the laptop data pipeline is no longer the only option for accessing big data systems. What already existed, server-side scheduled refresh using programmatic access tokens, updates unattended anywhere from every 10 seconds to weekly, your laptop is generally irrelevant to the data's freshness.

Let's give credit where it's due. This is JMP meeting me halfway. I had the ambition last year, 19.1 and 19.5 gave me the mechanism. Because I needed server-side table creation so I could keep delivering data access, full stop. The AI carrying my schema knowledge outward, so people with no data background could do a version of what I do, is a side benefit of this enhancement.

With those mechanisms in place, here's the idea that ties it all together. Hold on, I'm about to turn your JMP world upside down. I want to emphasize that what I'm about to explain to you is fundamentally different than how JMP and JMP Live are usually described. Most walkthroughs you will find start on the desktop: open the JMP client, open your data table, build the analysis, and then publish up to JMP Live. Notice the assumption buried in that? You have the data. We all know that getting the data was always the obstacle, and that leaves a data access gap for you to figure out.

In last year's presentation, I showed you how to connect JMP and JMP Live to large data systems to try and close that access gap and build on that process to achieve repeatable data refresh into your dashboard because my scientists were struggling with that part. These new features in 19.1 and JMP Live 19.5 allow me to run it the other way around and deliver faster. The data table was created in JMP Live first, server-side, and governed data lands there on a schedule, removing the desktop client from my process.

Only then does anyone analyze anything by pulling the table down into JMP from JMP Live, conducting their analysis, and publishing back up to JMP Live, which obviously connects to the data table and refreshes alongside it. I mean it here. JMP shipped the capability that makes this possible. Server-side table creation in 19.5 is what took the desktop client out of the loop, which removed the need for scientists to manage the connection infrastructure on their laptop that drives the data pipeline.

What changed for me? JMP Live remains a delivery channel to provide data as requested, but now the users have an actual self-service option that mimics how I deliver data: one governed source, deployed once, consumed by many, and it keeps arriving after I stop paying attention to it. Now the scientific community at IDEXX can do that themselves. JMP Live is now the front door to the data you're looking for.

Now seems like a good time to introduce you to QueryLab Dx, where it fits into this new approach. You bring the science and the question. You know what you're trying to learn and what a good number looks like and when a number smells wrong. That is the generally hard part, and it stays yours. JMP sits at the intersection of science and discovery, and you are the force that drives that discovery, not the AI.

The AI, QueryLab Dx, carries what I know about the data: where everything lives, what the fields mean, which view answers which question, and how to ask for it correctly. That is the knowledge I am paid to learn and maintain, and it is the part you were never given the time to learn and should not have to maintain, frankly, the part that keeps changing as our data model grows and matures. What the AI does is provide targeted SQL support to assist scientists in retrieving their data using plain language.

The server, JMP Live, it's the engine that keeps it running. It holds the connection to the data system, the SQL code to talk to it, and refreshes on schedule so nobody has to babysit a laptop. For example, you don't build or calibrate the mass spectrometer in order to trust its result. You rely on the systems, the standards, and the people who do that. You trust it because it's validated, controlled, and checked, not because you personally assembled it. Data should work the same way. You shouldn't have to build the pipeline to trust what comes out of it.

How does all this work? Let's open the door on how the AI actually understands you. To set some expectations here, I'm not going to hand-wave and say AI magic in the next few slides. You'll see exactly what it does with your words and exactly where the guardrails are. Let's start with what it is and the fact that it's already running in production.

This is today at IDEXX. This is not a prototype or a roadmap slide. QueryLab Dx turns a plain language question into governed, schema-aware SQL against IDEXX and Snowflake data. It's in production today, and it now covers four data ecosystems that are relevant to our scientific community: two distinct instrument-specific pipelines ingesting from a growing fleet, direct access to our reference lab data system for numerous use cases, and access to my warehouse for more advanced data products.

You ask a plain language question: multiplex heartworm positives from Grafton, last 14 days. That's it. That's the input. QueryLab pins down what you asked for against which ecosystem, views, columns, filters that have that information instead of guessing. When it can't tell, it asks you. It then proposes the scope, and if approved, writes the request as SQL. It's accurate, explainable, and inside our governance rules. The final step is programmatic validation. The request is checked against those rules, and you confirm it before anything runs. The AI will not proceed until you agree with its proposal. I specifically built it that way.

Now, you've seen the request in step one already. Let's explore how step two and three answer that. For any of you thinking about how AI can be implemented in your work, pay attention here. This is how you make them trustable and accurate in a governed data system. First, you ask like you'd ask a colleague: "I'm looking for multiplex heartworm positive samples from Grafton over the last 14 days." No syntax, no code, no table names, no schema definitions. That is a sentence any of you could say without preparing.

Second, it translates your words into the real thing. Grafton became lab location GRA because the data system stores location as abbreviations. Heartworm became Bead ID 39 because that is the universal bead ID for heartworm in this assay family. Here's the critical part. Those were resolved from governed definitions, not invented. The agent looked it up because I trained it to do that. It did not guess.

Finally, it reads the entire scope back to me: the view, the filters, the date window, the columns, and confirmed exactly how it resolved my request before writing anything. Think of QueryLab as an expert colleague who knows the data model cold, restates your request to make sure that you understood it, that you agree with what it's proposing, and it refuses to proceed until you both agree. QueryLab is not an autocomplete. It functions as a translator in a peer-review step. The next slide shows exactly how it resolved that request.

This is the whole trust argument in one picture. Multiplex locked the ecosystem. Had I left it out, it would have stopped and asked which domain. Grafton became Lab Location GRA plus Context ID 16, two fields from one word, resolved against governed definitions. Heartworm became Bead ID 39, the universal bead identity. Positive became result in positive or POS to cover the variations seen in that column. Last 14 days anchored to the date format used by the data system. Here's the point. Every value came out of governed definition files and the entire scope was read back for my approval before a single line of SQL existed. That is how the request gets built.

Here's the new part: what it hands back. The first version of QueryLab Dx stopped at SQL. This slide is what changed since then. Before you got SQL, correct, governed, explainable SQL, generally useful and still not a finished job because you then had to wire up a connection on your client, learn how to run it inside JMP, and hand-build the data table. I solved the hardest intellectual step, the conversation with the data system, and left the plumbing on your laptop. That gap is where adoption stalled. People got good SQL and never used it because the next step still demanded exactly the laptop-side connection skills that aren't there to begin with.

Now you get the validated SQL already wrapped in JSL, a complete, self-contained refresh script. You copy the whole block, you don't edit it, you don't fill in blanks, you don't uncomment anything, you paste it in the JMP Live refresh script and you're done. The difference is I went from giving people answers to giving them a working, deployable artifact.

Let me show you what that artifact is. Notice the header comment first: it records the question in plain language. Multiplex, heartworm, Grafton, last 14 days. Six months from now, whoever opens this report can read what it was asked, not reverse engineer it from SQL. Second, the connection line. The server owns that. The AI just knows how to put it in the code for you. Third, the query name. That's what the data table will be called in JMP Live, so reports stay identifiable in a workspace with hundreds of tables. Fourth, the custom SQL block. This is the governed SQL you just watched get resolved, properly escaped so JSL passes it through intact. Every filter here traces back to a phrase in your sentence. Nothing appeared you didn't ask for, and nothing you asked for got dropped. That's the auditability story in one screen.

Let's zoom back out. Here's the whole process start to finish. Four steps. Ask a plain language question, generate governed SQL plus the JSL wrapper, paste it into a JMP Live refresh script. The server manages the refresh and keeps it running, because the connector, the SQL, and the schedule all live on JMP Live. This is what the scientific community wants.

Here's the line I want you to take away: you started your journey inside JMP Live instead of building your way up to it. Historically, JMP Live was the last step, the reward at the end of a long climb. Now it's step one. That inversion is the whole redesign. I didn't make the climb easier, I removed it. What used to take days to weeks and broke often now takes minutes, and it's more governed than it was before, not less. Notice what nobody in that path ever did: log in to the database. This is a happy idea that surprises people, so I'll give it time to marinate. Nowhere in that demo did I log in to a Snowflake account. The JMP Live service account holds exactly one governed, read-only connection to the data warehouse, and it is the only thing that touches the data. What the scientist has is a browser and a question.

Let's cover what that removes: no account request, no provisioning queue, no credential that expires at the worst possible moment, no annual access review with your name on it. You IT-minded people in the room may already be thinking it. This is more governed, not less. One auditable service account with a read-only role replaces a personal database login for every scientist who ever wanted data. Database access is granted to the read-only service account. JMP Live manages the user access to the service account.

Now, one caveat worth stating out loud so nobody thinks I'm hand-waving: the service account is read-only and scoped to validated views. It cannot change anything. It cannot see anything I haven't already governed. The agent is only taught what the scientists need access to. This means that I can create versions of QueryLab Dx for HR, finance, reference labs, operations, distribution, and manufacturing, each with a very specific set of credentials with access to the data systems needed for that functional group. That's a lot.

Let's bring all this together and walk through the system end-to-end. You'll hear me say this a lot: you prove value when a scientist says, "That's exactly what I needed," not when the architecture diagram is elegant, not when the pipeline is fast, when a scientist gets exactly what they asked for and goes back to work. Let's look at how this comes together to achieve that goal. Your question does not jump straight to SQL. It moves through a series of checkpoints, and each one can pass it, rewrite it, or stop it cold. This is a pipeline with brakes.

Gate one, the behavior policy: the rules of engagement for what the agent may or may not do. It's purpose-built. It won't tell you jokes or give you dinner ideas. Its only job is to help you convert your question to SQL. The ecosystem gate. It helps determine which data domain your request lives in. Think of it like a GPS. The resolver layer. Your words map to real structure in the data system. The AI knows your common vocabulary and how it maps to the schema. The schema and JSON catalog. What actually exists in the data model so nothing can be invented by the AI.

Join governance. No unsafe joins because a wrong join is how you get a number that looks fine and is completely wrong. The validation gate. A final pre-flight check to review the proposed code and ensure the AI did not violate any rules. Finally, governed SQL. The trusted result, the explanation, and the option to revise it. Now, the important part: hallucinated joins, invented columns, unsafe SQL, these all get caught here before the query ever runs, rather than after a bad number has reached a decision. In our world, that distinction is everything. A bad number reaching a lot release decision is a serious problem. A bad query request that gets refused is a minor inconvenience.

Also worth noting, the rules live in documented version control. Governance you can read is governance you can audit. That's the functionality that QueryLab Dx brings.

Now that we've explored how it works, let me look at that demo again. As with any natural language model, give it a question in plain English. The difference is that QueryLab Dx returns governed SQL ready to run against Snowflake or wrap as a complete JSL refresh script for JMP Live. That block goes straight into JMP Live. The server holds the connection and refreshes on the schedule of your choosing.

Notice what isn't there. No driver to install on any computer, no hand-built data table, no laptop left running overnight so the report stays current. Notice what didn't change. The science in the question stays yours. The AI guardrails still refuse anything they can't validate. The output is immediately usable. That's the whole idea. You ask the question, you focus on the science, you let the system do the plumbing, and the report stays current on its own. What you just watched cost me one sentence and one paste. It took less than 5 minutes. My machine was a screen showing a browser. Every step in that is one a scientist can run themselves without a ticket, a driver, or a database skill they were never hired for. This is no longer a wishlist item. For IDEXX, this is our reality.

Where does this change your work? Let me be useful to the people in this room who do not work at IDEXX, because that is most of you. QueryLab Dx is mine, and even if I could share it with you, it's trained on IDEXX data, not yours. What is actually transferable from this presentation? All four of these, and none of them need an AI. One, put the connector on the server: one governed connection in a read-only service account held by JMP Live, not a driver and a personal login on every laptop in your group. You could do this on Monday with what you already own.

Two, create the data table in JMP Live first, set to refresh via script. This is the 19.5 capability, and it's the inversion. Nothing gets built locally, so nothing has to be published upward. Three, publish a view, not a one-off file. Whoever writes the query writes it once. What you hand over is a live table other people reuse, not an extract e-mailed around and stale by Thursday.

Four, and this is the honest one, the agent is an accelerator, not the architecture. Every benefit I have described today, the governance, the durability, no credentials on laptops, the report that outlives the person who built it, comes from where the work lives, not from the AI. A handwritten SQL string in the same JSL wrapper gets you this. QueryLab Dx just makes the create effortless. It did not make the architecture work. Remember this. If you build the architecture first, you are ready for whatever agent you eventually put in front of it.

This is the slide that decides whether anything in this talk actually happens, because the blocker is permission. Most of you cannot provision a service account yourself. Here's how I'd walk into that conversation with your IT. Ask for one service account, read-only, scoped to the views you consume. Be specific about scope. A vague ask is an easy no. Ask for the connection to be held on the server. The connector and the credential live on JMP Live, configured once, rather than on every laptop in your group.

Now, the important part. Ask for a named owner and a review date, one person on the IT side who owns the connection and a date to come back to it. A request like this rarely gets refused, it gets orphaned. Nobody says no, but nobody owns the follow-up either, and it quietly dies in someone's queue. Start with one report, not a platform. Ask for what a single existing report needs. A narrow first request gets approved by one person. A program gets a committee and a quarter.

Once it works, you get a problem you did not have before. Data access gets easier. I'm going to be honest that in this approach, it creates a problem it does not solve. Once deploying a governed table takes minutes instead of 3 weeks, people deploy a lot of them. That's a better problem than the one you had, but it's still a problem. Three habits keep it from getting away from you. Publish the widest useful table and filter in the report rather than in the query. One broad, governed table will answer 10 questions. Ten narrow tables answer one each, and then all need maintaining.

Name an owner, not a builder. Deploying takes minutes. Answering "Is this still right 6 months from now?" takes years of experience. Those are generally different jobs, and the second one is the one that helps keep the data product trustworthy. If nobody's name is on it, it will quietly rot. Extend before you duplicate. When someone wants a variant, add a column or a filter to the table that already exists instead of standing up a second one. This is the habit that everything else depends on.

The failure mode is worth naming out loud. Self-service that produces numerous overlapping tables is not a hypothetical. It's what happens by default because the architecture that makes deployment cheap makes proliferation cheap, too. A named owner and a bias toward extending rather than copying is the whole discipline.

Here's what I'd actually do next in your shoes. One, find out how your data actually gets there. For every report you rely on, ask one question: does it refresh itself, or does someone rerun it by hand? A lot of people generally don't know, and finding out is worth your time. Two, get your analysis off one laptop. If a report only lives on one machine, it stops when that person is on vacation, changes roles, or gets a new computer. Let JMP Live hold the connection instead. Three, stop repulling data by hand. You don't need to build the refresh yourself, you need to know that it ran and when.

Four, start your next question in JMP Live, not on your desktop. Begin with a live report in a generated script, so the analysis is reproducible from the first run. Here's some homework. Pick one report this month, just one, move it to the server, and see what it's like to stop owning the plumbing.

In summary, JMP Live 19.5 opens access to large data systems by helping the citizen scientist establish governance properties that would otherwise be out of reach: data source continuity, automatic refresh with visible audit trail, and one place of record instead of a single laptop. In the closing thought, last year, I automated the pipeline. This year, I turned JMP Live around and made it the door. Not the place your analysis ends up, the place it begins. The next question a scientist has shouldn't need an architect. Thanks for your time, and I'm happy to take any questions.

0 Comments
Presented At Discovery Summit 2026

Presenter

Skill level

Intermediate
  • Beginner
  • Intermediate
  • Advanced

Files

Published on ‎07-15-2026 03:39 PM by Community Manager Community Manager | Updated on ‎10-30-2026 03:34 PM

IDEXX QueryLab Dx introduces a new approach to expanding access to analytics by transforming natural-language questions into fully deployable analytical workflows within JMP. Rather than limiting AI to query assistance, this system extends the pipeline from intent to execution – generating governed SQL from structured data artifacts and automatically producing JMP Scripting Language (JSL) wrappers for direct deployment to JMP Live.

The system uses a staged, artifact-driven methodology that aligns user intent with enterprise data schemas, ensuring queries are accurate, explainable, and consistent with governance standards. Generated SQL is validated against predefined rules before being translated into JSL, creating a seamless bridge between data access and interactive analytics.

This approach addresses a common organizational challenge: analytics capabilities are often constrained by technical barriers, such as SQL and scripting expertise. By combining natural language interfaces, governed data access, and automated JSL generation, QueryLab Dx enables broader participation in analytics while preserving the rigor required in enterprise environments.

The presentation demonstrates an interactive JMP workflow, showing how users can generate, inspect, and deploy analytical outputs directly from natural-language input. It also highlights design patterns (such as schema-aware query generation, validation layers, and code synthesis), illustrating how AI can move beyond assistance to enable scalable, trustworthy analytic workflows across multidisciplinary teams.

 

 

Welcome back. My name is Chris Pillsbury, and I'm an R&D Data Solutions Architect at IDEXX Laboratories. Last year, I showed you the cloud data architecture I built to support our JMP and JMP Live users. This year is the follow-up, and it is aimed squarely at you as the scientist. If your data lives in a data system, then the AI agent I built, QueryLab Dx, is there to help you. At the end of this presentation, my hope is that you understand how you can get to governed, trustworthy, continually refreshing data without ever learning databases, SQL, or connectors. Not a lighter version of those skills. None of them.

To see why that matters, let's go back to where we left off last year. Last year, I built a fully automated ecosystem. Raw instrument and lab data is automatically moved to our cloud AWS storage. It shaped and validated Snowflake data models, which are accessible by JMP and JMP Live, and that was a real win. Data that used to be hand-carried in flash drives now arrives on its own in a database. But I want to be honest about what I could not solve until now. If a scientist wanted a new data set, one that I had not delivered to JMP Live yet, they still had only two options: file a request and wait for me, or roll up their sleeves and build their own connection on their own laptop.

Unfortunately, my attempts to train folks on how to do that were blocked by issues on their laptop that often required assistance from the IT help desk. Today, I solve that last step, remove that pain, and hand a new tool to the scientists. We have a full session today, six stops in 40 minutes.

First, the scientist's reality, why the gap between you and your data opened, and what it costs you. Second, where your data actually lives, a plain language picture of the data system. Third, two architectures, which is the heart of the talk. Whether the connector lives on your laptop or on the server decides who does the work. We open the box on QueryLab Dx, then from question to live report, the SQL, the JSL wrapper, and JMP Live 19.5. We close with governance and concrete takeaways you can take back to your own work and make progress.

But before we go any further, let's see what this looks like in practice. Before we talk about how the solution works, let's look at what the solution does. Here in this video, I'm asking the agent for heartworm positive samples from a specific location and within a date range. The agent then passes that prompt through a series of gates to resolve and generates SQL to address that request. While the agent is working, let me get the new data table set up and ready for the code. This is done by clicking the plus sign and selecting Data Table, naming it and adding in a description if you want, and then selecting Refresh Data via Script.

Just as soon as that's done, the agent responds and provides me with a summary of what it resolved from the original prompt, and requires me to accept that or change it before any SQL can be emitted. In my response, I approve the scope and make a request to have the code given to me for deployment in our JMP Live. The agent then passes that through a final gate and produces the SQL in a JMP Live compatible JSL wrapper. That code is then copy-pasted into JMP Live, and the data is refreshed, and after a short period, the table is produced from the SQL query.

This additional functionality, provided in JMP Live 19.5, gives us the option to deploy code directly in JMP Live, bypassing the client altogether. Let's get into it.

Data is the loop every one of you lives in, whether you know it or not. Science is iterative, data generation is dynamic, and data access is neither. Every follow-up question restarts the whole data request cycle in an ever-changing environment that's hard to get to. Let's spend some time on that.

Before I outline these, I want to explain where they came from, because this is not a story about anybody being underqualified. In less than a decade, the data you were used to analyzing moved. It used to be a file on an instrument PC or a shared drive, something you could open and extract files. Now it lives in a cloud warehouse behind an ODBC driver, a credential, and a VPN. The data got better, but reaching it got harder. This gap was never closed. It only concentrated the technical work by landing it on whoever could reach across the gap.

Once it lands on one person, that person's capacity becomes everyone else's ceiling. Every request queues behind one calendar. This is not just an IDEXX problem. If your company moved to a cloud warehouse, you opened the same gap. There is almost certainly one of your colleagues that people go to when they need data. The gap did not open because scientists stopped learning. It opened because the system moved faster than anyone could follow, and that gap continues to grow. It's nobody's fault, and yet it is still everyone's problem.

Let's name what that gap costs you, item by item. SQL isn't your native language, and learning it is a second career that nobody gave you time to start. ODBCs, connectors, drivers, and credentials on your laptop, this is a stack that breaks when IT pushes an update, when your password rotates, or when you get a new machine. Databases are unfamiliar and vast, and finding the right view comes second to making sure you even have access to the view you need. When a well-intentioned upstream IT team makes a change on the source system, a renamed column, a decode value, that shows up in the report as a number that suddenly looks wrong, and you're left to figure out why.

Instrument files were built for the instrument, and parsing raw machine output into something usable is hours of work before the science starts. The clock never stops. You have to make a decision now, today, to batch this lot. Every hour of data wrangling is an hour taken directly out of the science.

There are six frustrations on this slide, and if you're lucky, you can at least get the machine data parsed, albeit painfully. The rest boil down to these actual barriers: the connection and the database knowledge. The connector stack is what physically stops you from reaching the data, and the schema is what stops you from knowing what to ask for. These frustrations are what we call self-service.

Here's what the scientist actually wants: ask a question in plain language, get trustworthy governance SQL back, see it refresh on its own, and spend the saved time on the science. Four things, and none of them mention navigating 15 different Snowflake database schemas.

Here's what today's self-service asks of you in exchange: install and maintain ODBC drivers, store database credentials on your laptop, learn the schema and write SQL, build a client-side data table, then publish it up to JMP Live, and personally own the refresh from then on. That's five infrastructure jobs bolted onto a scientist's job description. We handed people a toolkit and called it empowerment. Self-service should mean the service does more, not that you do more. If the only way to serve yourself is to become a part-time data engineer, that isn't self-service, it's delegation of unfunded work.

But before I show you the fix, I want to fix something else first: the fact that nobody ever explained the data system to you. Historically, the data you generated lived wherever it landed, an export folder on the instrument PC or a shared drive. Today, that same data may be moved into a cloud data system, captured on a schedule and not something you have access to. Once you had the data, you cleaned it with the filters and fixes you did from memory that nobody else can reproduce.

In the data system, that work happens for each data file that gets ingested and is cleaned and ready to analyze automatically. When you needed data, you grabbed the flash drive. Now in the data system, you have to write some SQL code to get the precise slice you asked for and nothing else. Here's the point, and it's the thesis of the whole talk: you already know where your data comes from. You generated it. But where it goes seems like a corn maze. What you never had is a managed, governed access point to the data system and a plain language way to ask for your data back. That's what JMP Live 19.5 and generative AI provides.

Now, there's one decision that changes everything about your data access, and it's a decision most people never realized was made: where does the data connector live? Because where the connector lives decides who does the work. This is the single most important sentence in this talk. If you remember nothing else, remember this one.

Now, let's take a look at the two architectures one at a time, starting with the one most of you are living in today. This is the traditional model, and it works as long as one very specific machine is healthy: yours. Your laptop holds the JMP desktop client. On that laptop, you install an ODBC driver, define a DSN, and store your database credentials. You connect over VPN, you run the query, and JMP builds the data table that lives on your computer. When you want current numbers, you repeat the process. When you want colleagues to see it, you share it or you publish it to JMP Live. But that means you have to connect, authenticate, query, refresh, and publish. Every one of them is a place where your afternoon can disappear.

It's fragile. These are the things that break it: password rotation, a new laptop, a loaner laptop, vacation, leaving the company. Usually, nobody notices until the number on someone's dashboard is 3 months stale because the author moved to a new department. Now, watch what happens when we move exactly one thing: the connector, off your laptop and onto the server. A browser. That's it. That's the whole story of this slide. Same Snowflake, same report, one difference: everything in the middle moved to the JMP Live server.

The server holds a governed connector backed by a service account and runs the refresh on a schedule. The report and dashboard automatically update and are accessible at a URL you can share with any JMP Live user. Your laptop, you open a link in a web browser. No ODBC, no DSN, no credentials on your laptop. The data refreshes whether your laptop is on or off, whether you're at the bench, on a plane, or on vacation, whether you even still work there. That's the last point that matters more than it sounds. Continuity is a governance property. When the plumbing belongs to the server, institutional knowledge stops walking out the door with individuals.

Now, let me put those two models side by side so the trade is unmistakable. One difference drives this whole table: where the connector lives. Everything below is a consequence of row one. The credentials, they're yours to manage them, or you borrow the server's access. On the desktop, you install and keep the ODBC and DSN working. In JMP Live, there's nothing for you to manage but your contributions. The desktop refresh is manual, and it only happens if your laptop is on. JMP Live is scheduled and refreshes on its own.

Now, this turns a tooling preference into a business risk. If you're out or if you leave, the desktop report goes stale and quietly, and usually, nobody notices until someone makes a decision on an old number. For JMP Live, it keeps running until someone stops it. In the last row is the real point: desktop means you manage the whole pipeline, JMP Live means you manage just the question. The question is why the system was built in the first place. How bad is it right now? In my experience, managing the laptop-side connection is the single biggest blocker standing between a scientist and their data. Not the SQL, the connection.

Start with what it actually asks of you. An ODBC driver needs administrator rights on your machine, rights most scientists do not have. The driver is version-locked to a database, so someone has to tell you the right one to use. Then the part that really ends adoption: when the connection breaks, there is no diagnostic step available to you. You file a ticket and you wait. The analysis you were doing this morning is now next week's problem. It never stops costing. A credential to store and rotate, a refresh nobody babysits, per laptop, per new machine, per password rotation, indefinitely.

Say your group is 5, 20, or, like me, 300 people large. Multiply managing those three recurring costs, driver, credential, refresh, by every person who needs data, against one connection and one service account set up once on the server. That is the reason laptop data pipelines never scaled, and it's why "just give everyone access" was never actually the answer. The required skills simply were not there to support it. To be clear, this barrier is mine, too. Same drivers, same version locks, same breakage on every connection I maintain to deliver data to somebody else. How does JMP Live help?

Two things shipped recently that make server-side model practical rather than aspirational. To be honest, none of this was practical even 4 months ago. First, the REST-based Snowflake connector, new in JMP 19.1. It's faster than ODBC, and it was designed for server-side use. Second, and this is the one that unlocks the whole talk, server-side scripted refresh isn't new. JMP Live was built to do that. What JMP 19.5 added is the ability to create a new data table server-side without publishing it from the desktop first. That means the laptop data pipeline is no longer the only option for accessing big data systems. What already existed, server-side scheduled refresh using programmatic access tokens, updates unattended anywhere from every 10 seconds to weekly, your laptop is generally irrelevant to the data's freshness.

Let's give credit where it's due. This is JMP meeting me halfway. I had the ambition last year, 19.1 and 19.5 gave me the mechanism. Because I needed server-side table creation so I could keep delivering data access, full stop. The AI carrying my schema knowledge outward, so people with no data background could do a version of what I do, is a side benefit of this enhancement.

With those mechanisms in place, here's the idea that ties it all together. Hold on, I'm about to turn your JMP world upside down. I want to emphasize that what I'm about to explain to you is fundamentally different than how JMP and JMP Live are usually described. Most walkthroughs you will find start on the desktop: open the JMP client, open your data table, build the analysis, and then publish up to JMP Live. Notice the assumption buried in that? You have the data. We all know that getting the data was always the obstacle, and that leaves a data access gap for you to figure out.

In last year's presentation, I showed you how to connect JMP and JMP Live to large data systems to try and close that access gap and build on that process to achieve repeatable data refresh into your dashboard because my scientists were struggling with that part. These new features in 19.1 and JMP Live 19.5 allow me to run it the other way around and deliver faster. The data table was created in JMP Live first, server-side, and governed data lands there on a schedule, removing the desktop client from my process.

Only then does anyone analyze anything by pulling the table down into JMP from JMP Live, conducting their analysis, and publishing back up to JMP Live, which obviously connects to the data table and refreshes alongside it. I mean it here. JMP shipped the capability that makes this possible. Server-side table creation in 19.5 is what took the desktop client out of the loop, which removed the need for scientists to manage the connection infrastructure on their laptop that drives the data pipeline.

What changed for me? JMP Live remains a delivery channel to provide data as requested, but now the users have an actual self-service option that mimics how I deliver data: one governed source, deployed once, consumed by many, and it keeps arriving after I stop paying attention to it. Now the scientific community at IDEXX can do that themselves. JMP Live is now the front door to the data you're looking for.

Now seems like a good time to introduce you to QueryLab Dx, where it fits into this new approach. You bring the science and the question. You know what you're trying to learn and what a good number looks like and when a number smells wrong. That is the generally hard part, and it stays yours. JMP sits at the intersection of science and discovery, and you are the force that drives that discovery, not the AI.

The AI, QueryLab Dx, carries what I know about the data: where everything lives, what the fields mean, which view answers which question, and how to ask for it correctly. That is the knowledge I am paid to learn and maintain, and it is the part you were never given the time to learn and should not have to maintain, frankly, the part that keeps changing as our data model grows and matures. What the AI does is provide targeted SQL support to assist scientists in retrieving their data using plain language.

The server, JMP Live, it's the engine that keeps it running. It holds the connection to the data system, the SQL code to talk to it, and refreshes on schedule so nobody has to babysit a laptop. For example, you don't build or calibrate the mass spectrometer in order to trust its result. You rely on the systems, the standards, and the people who do that. You trust it because it's validated, controlled, and checked, not because you personally assembled it. Data should work the same way. You shouldn't have to build the pipeline to trust what comes out of it.

How does all this work? Let's open the door on how the AI actually understands you. To set some expectations here, I'm not going to hand-wave and say AI magic in the next few slides. You'll see exactly what it does with your words and exactly where the guardrails are. Let's start with what it is and the fact that it's already running in production.

This is today at IDEXX. This is not a prototype or a roadmap slide. QueryLab Dx turns a plain language question into governed, schema-aware SQL against IDEXX and Snowflake data. It's in production today, and it now covers four data ecosystems that are relevant to our scientific community: two distinct instrument-specific pipelines ingesting from a growing fleet, direct access to our reference lab data system for numerous use cases, and access to my warehouse for more advanced data products.

You ask a plain language question: multiplex heartworm positives from Grafton, last 14 days. That's it. That's the input. QueryLab pins down what you asked for against which ecosystem, views, columns, filters that have that information instead of guessing. When it can't tell, it asks you. It then proposes the scope, and if approved, writes the request as SQL. It's accurate, explainable, and inside our governance rules. The final step is programmatic validation. The request is checked against those rules, and you confirm it before anything runs. The AI will not proceed until you agree with its proposal. I specifically built it that way.

Now, you've seen the request in step one already. Let's explore how step two and three answer that. For any of you thinking about how AI can be implemented in your work, pay attention here. This is how you make them trustable and accurate in a governed data system. First, you ask like you'd ask a colleague: "I'm looking for multiplex heartworm positive samples from Grafton over the last 14 days." No syntax, no code, no table names, no schema definitions. That is a sentence any of you could say without preparing.

Second, it translates your words into the real thing. Grafton became lab location GRA because the data system stores location as abbreviations. Heartworm became Bead ID 39 because that is the universal bead ID for heartworm in this assay family. Here's the critical part. Those were resolved from governed definitions, not invented. The agent looked it up because I trained it to do that. It did not guess.

Finally, it reads the entire scope back to me: the view, the filters, the date window, the columns, and confirmed exactly how it resolved my request before writing anything. Think of QueryLab as an expert colleague who knows the data model cold, restates your request to make sure that you understood it, that you agree with what it's proposing, and it refuses to proceed until you both agree. QueryLab is not an autocomplete. It functions as a translator in a peer-review step. The next slide shows exactly how it resolved that request.

This is the whole trust argument in one picture. Multiplex locked the ecosystem. Had I left it out, it would have stopped and asked which domain. Grafton became Lab Location GRA plus Context ID 16, two fields from one word, resolved against governed definitions. Heartworm became Bead ID 39, the universal bead identity. Positive became result in positive or POS to cover the variations seen in that column. Last 14 days anchored to the date format used by the data system. Here's the point. Every value came out of governed definition files and the entire scope was read back for my approval before a single line of SQL existed. That is how the request gets built.

Here's the new part: what it hands back. The first version of QueryLab Dx stopped at SQL. This slide is what changed since then. Before you got SQL, correct, governed, explainable SQL, generally useful and still not a finished job because you then had to wire up a connection on your client, learn how to run it inside JMP, and hand-build the data table. I solved the hardest intellectual step, the conversation with the data system, and left the plumbing on your laptop. That gap is where adoption stalled. People got good SQL and never used it because the next step still demanded exactly the laptop-side connection skills that aren't there to begin with.

Now you get the validated SQL already wrapped in JSL, a complete, self-contained refresh script. You copy the whole block, you don't edit it, you don't fill in blanks, you don't uncomment anything, you paste it in the JMP Live refresh script and you're done. The difference is I went from giving people answers to giving them a working, deployable artifact.

Let me show you what that artifact is. Notice the header comment first: it records the question in plain language. Multiplex, heartworm, Grafton, last 14 days. Six months from now, whoever opens this report can read what it was asked, not reverse engineer it from SQL. Second, the connection line. The server owns that. The AI just knows how to put it in the code for you. Third, the query name. That's what the data table will be called in JMP Live, so reports stay identifiable in a workspace with hundreds of tables. Fourth, the custom SQL block. This is the governed SQL you just watched get resolved, properly escaped so JSL passes it through intact. Every filter here traces back to a phrase in your sentence. Nothing appeared you didn't ask for, and nothing you asked for got dropped. That's the auditability story in one screen.

Let's zoom back out. Here's the whole process start to finish. Four steps. Ask a plain language question, generate governed SQL plus the JSL wrapper, paste it into a JMP Live refresh script. The server manages the refresh and keeps it running, because the connector, the SQL, and the schedule all live on JMP Live. This is what the scientific community wants.

Here's the line I want you to take away: you started your journey inside JMP Live instead of building your way up to it. Historically, JMP Live was the last step, the reward at the end of a long climb. Now it's step one. That inversion is the whole redesign. I didn't make the climb easier, I removed it. What used to take days to weeks and broke often now takes minutes, and it's more governed than it was before, not less. Notice what nobody in that path ever did: log in to the database. This is a happy idea that surprises people, so I'll give it time to marinate. Nowhere in that demo did I log in to a Snowflake account. The JMP Live service account holds exactly one governed, read-only connection to the data warehouse, and it is the only thing that touches the data. What the scientist has is a browser and a question.

Let's cover what that removes: no account request, no provisioning queue, no credential that expires at the worst possible moment, no annual access review with your name on it. You IT-minded people in the room may already be thinking it. This is more governed, not less. One auditable service account with a read-only role replaces a personal database login for every scientist who ever wanted data. Database access is granted to the read-only service account. JMP Live manages the user access to the service account.

Now, one caveat worth stating out loud so nobody thinks I'm hand-waving: the service account is read-only and scoped to validated views. It cannot change anything. It cannot see anything I haven't already governed. The agent is only taught what the scientists need access to. This means that I can create versions of QueryLab Dx for HR, finance, reference labs, operations, distribution, and manufacturing, each with a very specific set of credentials with access to the data systems needed for that functional group. That's a lot.

Let's bring all this together and walk through the system end-to-end. You'll hear me say this a lot: you prove value when a scientist says, "That's exactly what I needed," not when the architecture diagram is elegant, not when the pipeline is fast, when a scientist gets exactly what they asked for and goes back to work. Let's look at how this comes together to achieve that goal. Your question does not jump straight to SQL. It moves through a series of checkpoints, and each one can pass it, rewrite it, or stop it cold. This is a pipeline with brakes.

Gate one, the behavior policy: the rules of engagement for what the agent may or may not do. It's purpose-built. It won't tell you jokes or give you dinner ideas. Its only job is to help you convert your question to SQL. The ecosystem gate. It helps determine which data domain your request lives in. Think of it like a GPS. The resolver layer. Your words map to real structure in the data system. The AI knows your common vocabulary and how it maps to the schema. The schema and JSON catalog. What actually exists in the data model so nothing can be invented by the AI.

Join governance. No unsafe joins because a wrong join is how you get a number that looks fine and is completely wrong. The validation gate. A final pre-flight check to review the proposed code and ensure the AI did not violate any rules. Finally, governed SQL. The trusted result, the explanation, and the option to revise it. Now, the important part: hallucinated joins, invented columns, unsafe SQL, these all get caught here before the query ever runs, rather than after a bad number has reached a decision. In our world, that distinction is everything. A bad number reaching a lot release decision is a serious problem. A bad query request that gets refused is a minor inconvenience.

Also worth noting, the rules live in documented version control. Governance you can read is governance you can audit. That's the functionality that QueryLab Dx brings.

Now that we've explored how it works, let me look at that demo again. As with any natural language model, give it a question in plain English. The difference is that QueryLab Dx returns governed SQL ready to run against Snowflake or wrap as a complete JSL refresh script for JMP Live. That block goes straight into JMP Live. The server holds the connection and refreshes on the schedule of your choosing.

Notice what isn't there. No driver to install on any computer, no hand-built data table, no laptop left running overnight so the report stays current. Notice what didn't change. The science in the question stays yours. The AI guardrails still refuse anything they can't validate. The output is immediately usable. That's the whole idea. You ask the question, you focus on the science, you let the system do the plumbing, and the report stays current on its own. What you just watched cost me one sentence and one paste. It took less than 5 minutes. My machine was a screen showing a browser. Every step in that is one a scientist can run themselves without a ticket, a driver, or a database skill they were never hired for. This is no longer a wishlist item. For IDEXX, this is our reality.

Where does this change your work? Let me be useful to the people in this room who do not work at IDEXX, because that is most of you. QueryLab Dx is mine, and even if I could share it with you, it's trained on IDEXX data, not yours. What is actually transferable from this presentation? All four of these, and none of them need an AI. One, put the connector on the server: one governed connection in a read-only service account held by JMP Live, not a driver and a personal login on every laptop in your group. You could do this on Monday with what you already own.

Two, create the data table in JMP Live first, set to refresh via script. This is the 19.5 capability, and it's the inversion. Nothing gets built locally, so nothing has to be published upward. Three, publish a view, not a one-off file. Whoever writes the query writes it once. What you hand over is a live table other people reuse, not an extract e-mailed around and stale by Thursday.

Four, and this is the honest one, the agent is an accelerator, not the architecture. Every benefit I have described today, the governance, the durability, no credentials on laptops, the report that outlives the person who built it, comes from where the work lives, not from the AI. A handwritten SQL string in the same JSL wrapper gets you this. QueryLab Dx just makes the create effortless. It did not make the architecture work. Remember this. If you build the architecture first, you are ready for whatever agent you eventually put in front of it.

This is the slide that decides whether anything in this talk actually happens, because the blocker is permission. Most of you cannot provision a service account yourself. Here's how I'd walk into that conversation with your IT. Ask for one service account, read-only, scoped to the views you consume. Be specific about scope. A vague ask is an easy no. Ask for the connection to be held on the server. The connector and the credential live on JMP Live, configured once, rather than on every laptop in your group.

Now, the important part. Ask for a named owner and a review date, one person on the IT side who owns the connection and a date to come back to it. A request like this rarely gets refused, it gets orphaned. Nobody says no, but nobody owns the follow-up either, and it quietly dies in someone's queue. Start with one report, not a platform. Ask for what a single existing report needs. A narrow first request gets approved by one person. A program gets a committee and a quarter.

Once it works, you get a problem you did not have before. Data access gets easier. I'm going to be honest that in this approach, it creates a problem it does not solve. Once deploying a governed table takes minutes instead of 3 weeks, people deploy a lot of them. That's a better problem than the one you had, but it's still a problem. Three habits keep it from getting away from you. Publish the widest useful table and filter in the report rather than in the query. One broad, governed table will answer 10 questions. Ten narrow tables answer one each, and then all need maintaining.

Name an owner, not a builder. Deploying takes minutes. Answering "Is this still right 6 months from now?" takes years of experience. Those are generally different jobs, and the second one is the one that helps keep the data product trustworthy. If nobody's name is on it, it will quietly rot. Extend before you duplicate. When someone wants a variant, add a column or a filter to the table that already exists instead of standing up a second one. This is the habit that everything else depends on.

The failure mode is worth naming out loud. Self-service that produces numerous overlapping tables is not a hypothetical. It's what happens by default because the architecture that makes deployment cheap makes proliferation cheap, too. A named owner and a bias toward extending rather than copying is the whole discipline.

Here's what I'd actually do next in your shoes. One, find out how your data actually gets there. For every report you rely on, ask one question: does it refresh itself, or does someone rerun it by hand? A lot of people generally don't know, and finding out is worth your time. Two, get your analysis off one laptop. If a report only lives on one machine, it stops when that person is on vacation, changes roles, or gets a new computer. Let JMP Live hold the connection instead. Three, stop repulling data by hand. You don't need to build the refresh yourself, you need to know that it ran and when.

Four, start your next question in JMP Live, not on your desktop. Begin with a live report in a generated script, so the analysis is reproducible from the first run. Here's some homework. Pick one report this month, just one, move it to the server, and see what it's like to stop owning the plumbing.

In summary, JMP Live 19.5 opens access to large data systems by helping the citizen scientist establish governance properties that would otherwise be out of reach: data source continuity, automatic refresh with visible audit trail, and one place of record instead of a single laptop. In the closing thought, last year, I automated the pipeline. This year, I turned JMP Live around and made it the door. Not the place your analysis ends up, the place it begins. The next question a scientist has shouldn't need an architect. Thanks for your time, and I'm happy to take any questions.



Start:
Thu, Oct 22, 2026 09:00 AM EDT
End:
Thu, Oct 22, 2026 09:45 AM EDT
Key Ballroom 11
Attachments
0 Kudos