Executive Insights and Trends
The Agent Era Has a Data Problem. Qlik Solves It.
It’s clear that we are in the early innings of an unparalleled shift in how knowledge work gets done across the board. If you pull forward the changes we’ve already seen from teams who have adopted agents in software development and apply them to broader categories of knowledge work, you can see how these patterns will lead to a fundamental rethinking of the relationship and responsibilities between humans, software, and data. The products and platforms that win won't be the ones just rebranding their existing products with AI labels. Instead, winners will be the ones whose architecture was already built for programmatic intelligence.
The difference between the adoption we see in the domain of engineering and the delay in adoption in broader knowledge work is this – agents cannot accomplish the tasks without data, the relevant context, or the associations. This isn’t a problem that can be solved with better prompts. The gap will lead to a fundamental rethinking of data: governed, structured, repeatable data products – with interfaces designed to be consumed by agents.
Frontier LLMs were not designed to build or manage the data foundation that is required for the enterprise, and that distinction matters more than almost anything else right now.
What Frontier LLMs Are and Aren't
Frontier LLMs are probabilistic reasoning systems. That's exactly what makes them powerful—synthesis, interpretation, problem solving, language. But that same design makes them poorly suited for something enterprises depend on every day: deterministic data operations or conclusions and insights businesses want to get our of their data. The kind of things that require governance, repeatability, structured execution that produces the same correct answer twice.
To work effectively in enterprise environments, LLMs rely on external tools, connectors, and structured systems to supply governed data, context, and executable workflows. Those capabilities live outside the model, they're not generated or enforced by it. They are increasingly being used through things like Connectors and MCP and a new ecosystem is unfolding around this today.
When many people hear “data products”, they think “curated datasets”. In practice, this is much broader – including governance, versioning, contracts, lineage, ontologies, quality – and it must be built in a way that can be used by both agents and humans.
What "AI-Native" Actually Means
A genuinely AI-native platform has three non-negotiables:
API-first design. Whatever a human can do in the UI, an agent can do through APIs. No exceptions. No capability walls.
Contextual intelligence. The system gets smarter from accumulated context and interaction patterns, not just from piling more data into tables.
Adaptive workflows. The platform bends to how users actually work, not the other way around.
Most legacy platforms fail all three. Users click buttons. Agents hit API walls or find whole capabilities that only exist in the GUI. Context resets every session. Workflows stay frozen in whatever the product team decided five years ago.
This is an architectural problem, not a cosmetic one. And you can’t patch your way out of it.
Interoperability Is the Requirement Everyone’s Underselling
As the ecosystem matures, agents will increasingly rely on standards-based ways to discover and invoke connections to adjacent systems. This includes MCP and A2A today, though solid APIs and a well written skill may perform just as well.
That makes interoperability critical in a way it simply hasn't been before.
Platforms that expose governed data, semantic context, and analytical capabilities through open, well-structured interfaces become force multipliers for agents. Platforms that don't? They become bottlenecks—regardless of how sophisticated the underlying technology may be.
Closed architectures get routed around, made irrelevant, and replaced. Open, interoperable ones get reached for first.
That is one reason Qlik is well positioned for this change. Our cloud-native architecture, strong patterns for services, APIs, and defined domains have made it straightforward for us to expose our capabilities to all of the AI channels, along with whatever will come next. As our users adopt AI tools to get their jobs done instead of the browser and the UI, we are embracing the shift to Omnichannel AI, meaning we will ensure that the value our users get from the Qlik platform across the board is available in this next generation of tools.
Why Qlik’s Architecture is Positioned for This
Qlik's architecture wasn't originally designed for LLM-based agents. No one could have predicted this wave when we built our core technology. But the architectural decisions we made over time position us at exactly the right intersection of data analytics and AI agents.
The In-Memory Associative Engine
Think about a typical agent workflow. An AI agent needs to answer questions about household income trends across regions. It pulls from public datasets, combines that with internal customer data, runs calculations, generates visualizations, delivers insights—all from a natural language conversation.
Legacy BI tools fall apart here. Rigid data pipelines, predefined data models, gaps in context for schemas, manual dashboard creation. An agent can't just spin up an analytical environment on demand.
The Qlik engine can.
Our in-memory associative technology lets agents ingest data from any source programmatically, discover relationships automatically without predefined joins or schema wrangling, run complex calculations instantly, and generate any visualization on the fly. A one-time analytical workflow can start and end with a single question. If it’s worth savings for the long term, you can keep it.
This isn't a bolt-on feature. It's how the engine works.
A Semantic Context Engine, Not Just a Query Layer
This is where the real differentiation starts to emerge.
One of the biggest challenges for agents working with existing, structured enterprise data is ambiguity. What is the definition of a given metric? Which relationships matter? Without strong semantic context, even state of the art models struggle.
Qlik has the ingredients to address that problem. Our metadata layer, associated model, and analytics logic can provide governed semantic context that helps agents reason with greater accuracy over structured datasets. Combined with metric definitions, lineage, and governed access patterns, that architecture can function as a semantic context engine.
That matters because the goal is not just for the agents to talk about data. It’s for them to work with the right business logic, the right relationships, and the right definitions every time. In that model, Qlik becomes the environment you use when accurate, explainable responses from LLMs matter – in this next wave of change for knowledge work.
Everything Is Programmable
Everything you can do in Qlik's drag-and-drop interface can also be done programmatically through APIs. The scripting language, chart creation, application assembly, data model definition, security rules, calculation logic—all of it. API capabilities and UI capabilities are built on the same foundation.
An agent using Qlik APIs has the same power as a human user with full access, and in some cases, more. Agents can orchestrate complex multi-step workflows faster than any human could click through them.
Beyond Generic Tool Calls
Most conversations about AI agents and data platforms stop at basic tool calls with agents pinging a system for query results. Useful, but limited.
Agents working with Qlik can go much deeper. Using our metadata layer, data constructs, and analytics logic, they can access curated semantic context and execute genuinely deterministic analytical operations. Not approximate answers. Not probabilistic outputs. Governed, repeatable, structured results—the kind enterprises depend on.
That's the difference between an agent that reasons about data and one that can reliably act on it. And in production environments that enterprises depend on, that gap is enormous.
The Agent-Driven Analytics Workflow
A financial analyst asks an agent: "How does our Q4 customer retention compare to industry benchmarks? Which segments are underperforming?"
The agent pulls internal customer data from the warehouse and industry benchmarks from external sources through programmatic data connections. It uses Qlik's scripting engine to transform, clean, and associate the datasets—the associative engine discovers relationships automatically. It runs retention calculations, segments customers by industry, size, and behavior, computes variance from benchmarks. Builds exactly the charts needed to answer the question. Delivers findings in natural language backed by interactive visualizations the analyst can dig into further.
All of this in one fluid conversation. No manual dashboard building. No waiting on IT. No rigid predetermined views. The analyst stays in flow. The agent handles the orchestration.
Why This Changes the Economics of Analytics
The traditional analytics workflow is expensive—in time, headcount, and iteration cycles.
Business users articulate needs. Analysts translate those into technical requirements. Engineers build pipelines. BI developers build dashboards. Business users consume predefined views. Repeat for every new question. It's a slow, lossy game of telephone, and most people in this industry have just accepted it as normal.
The agent-enabled model collapses that chain. Questions get asked in natural language. Agents orchestrate the technical workflow. Insights are generated on-demand. New questions get answered immediately, not queued.
But here's what I think matters most: agentic workflows become cheaper, faster, and more reliable when intelligence is distributed across the system rather than concentrated in the LLM. The LLM handles interpretation and reasoning. Qlik handles deterministic analytical execution. That division of labor is what makes the whole system trustworthy at enterprise scale, and at the same time, gets more cost-efficient efficient token utilization.
Qlik as the Runtime, Not Just the Platform
This is where it gets genuinely interesting.
Qlik doesn't have to be just a data platform that agents query. The architecture supports something more significant: becoming the runtime environment where data-driven agents operate.
In this model, LLMs provide the reasoning. Qlik provides the governed context, structured execution, and high-performance access to enterprise data. The agent isn't improvising through unstructured information—it's operating within a governed, semantically rich environment that was purpose-built for analytical work.
That's a fundamentally different, and defensible positioning.
It also draws the clearest possible line between AI-native and AI-enhanced and it will become obvious in the next 18 months. AI-enhanced products deliver neat demos and modest productivity bumps but their impact will round to zero. AI-native platforms—ones where the division of labor between LLM reasoning and deterministic execution works as designed—enable fundamentally new ways of operating. The gap between them is like mounting a GPS screen on a horse-drawn carriage versus building a supercar from scratch. Same destination, completely different architecture, completely different speeds.
What We're Building Next
This isn't about sitting back and letting our architecture do the work for us. We're actively building out more of the pieces that makes this vision real:
Agent-optimized APIs — More agent-friendly interfaces with natural language descriptions, clear tool specs, simplified authentication
Context preservation — Agents that build and maintain context across analytical sessions, so follow-up questions build on previous insights rather than starting cold
Workflow templates — Patterns and blueprints for common agent-driven analytical workflows
Governance for agents — Extending our security and governance frameworks to manage agent access appropriately
Deeper model integrations — Stronger interoperability with leading LLMs and emerging agent frameworks, plus specialized analytics agents built on Qlik's in-memory data architecture
The goal isn't to compete with frontier models. It's to be the governed analytical runtime they depend on when the work actually matters.
An Invitation
If you're building AI agents or rolling out AI tools for your users that need to build data pipelines, analyze data, create visualizations, or generate insights, you should explore what Qlik's architecture actually enables. We're not talking about sending data to a BI tool and getting back a static report. We're talking about giving agents the full power of an enterprise analytics platform: data transformation and governance, associative exploration, calculation, visualization—all through programmatic interfaces, with the deterministic reliability enterprise environments require.
LLMs provide the intelligence. Qlik provides the foundation it runs on.
The agent era is here. The platforms ready for it were already built for intelligence—human and artificial—to work together.
Want to explore how Qlik's AI-native architecture can power your agent workflows? Connect with our team or check out our developer documentation here.