Raising the quality of insights in agentic analytics

We have spent the last three years watching generative AI transition from a novelty trick into a foundational layer for enterprise software. The first wave was all about accessibility. We moved from requiring a data science degree to just needing a natural language prompt. It was a victory for democratization, but it was also shallow. Now, the industry is moving toward the agentic era, where models do not just summarize data; they act on it.

The Promise of the Agentic Workflow

In theory, agentic analytics is the holy grail for founders. Instead of a dashboard that tells you churn is up 5%, you have an agent that identifies why, develops a retention campaign, and triggers the emails. This shift from passive observation to active participation is what every enterprise SaaS company is currently selling. They want to move beyond the chatbot interface and into autonomous execution.

For a builder, this sounds like the ultimate efficiency gain. If you can automate the cycle of analysis, decision-making, and execution, you have effectively scaled your most expensive human talent. But as someone who has lived through multiple hype cycles, I see a glaring problem that many are ignoring: the quality of the insights that drive these actions.

The Garbage In, Garbage Out Dilemma

The core issue with current agentic systems is that they are still fundamentally probabilistic. An AI agent might be great at writing code or summarizing a meeting, but when it comes to deep analytical reasoning, it often lacks the context to understand nuance. If the insight generated at the start of the chain is flawed, every subsequent action taken by the agent is also flawed.

Most of the current enterprise AI tools rely on RAG (Retrieval-Augmented Generation) to ground their answers in company data. While RAG reduces hallucinations, it does not necessarily improve analytical depth. An agent might accurately report that sales are down, but it might completely fail to realize that the decline is due to a seasonal holiday that was not explicitly labeled in the dataset. If that agent then decides to slash the marketing budget based on that incomplete insight, the technology has become a liability rather than an asset.

Why Builders Should Be Skeptical of Autonomy

I have spoken to dozens of founders who are rushing to add agentic features to their roadmaps. My advice is always the same: do not prioritize autonomy over accuracy. A tool that is 90% accurate is useful as a copilot but dangerous as an agent. In a copilot scenario, a human checks the work. In an agentic scenario, the human is often out of the loop until something breaks.

The complexity of enterprise data is the real hurdle here. Most company data is messy, siloed, and full of contradictions. Expecting a large language model to navigate these inconsistencies and produce high-level strategic insights is a big ask. We are asking models trained on the open internet to understand the specific, idiosyncratic logic of a private corporation. That gap is where most agentic projects fail.

Solving for Insight Quality

So, how do we actually raise the bar for these insights? It starts with narrowing the scope. The mistake most teams make is trying to build a general-purpose analyst agent. Instead, builders should be focusing on hyper-specific agents that operate within constrained environments.

• Deterministic Guardrails: Do not let the agent guess. Build systems that force the agent to use predefined analytical frameworks rather than free-form reasoning.
• Human-in-the-Loop Validation: For high-stakes actions, the agent should propose an insight and an action, but a human should still pull the trigger. We are not at the point where we can trust the machines with the keys to the kingdom yet.
• Better Data Contextualization: Feed the agent more than just raw numbers. It needs metadata, historical context, and business logic that usually exists only in the heads of senior management.

The Economic Reality of AI Agents

Building high-quality agentic systems is expensive. It requires more compute, more sophisticated prompting, and significantly more testing than a standard chatbot. Many startups are going to find that the unit economics of providing truly high-quality insights are difficult to justify. If you have to run ten different reasoning chains to verify one insight, your API costs are going to skyrocket.

We are also seeing a shift in what customers actually want. The initial awe of AI is wearing off. Users are becoming more discerning. They are starting to notice when an AI-generated insight is just a rehash of obvious information. To survive the next two years, builder-first companies need to focus on generating insights that are non-obvious and highly actionable.

The value of an agent is not found in how fast it works, but in how few mistakes it makes when no one is watching.

What This Means for the Future

The transition to agentic analytics is inevitable, but the road is going to be littered with failed experiments. The winners will not be the companies with the flashiest demos; they will be the ones who figured out how to make their agents as reliable as a senior human analyst. This requires a level of engineering rigor that many AI startups currently lack.

We need to stop treating AI as a magic box and start treating it as a new type of software architecture. This architecture requires new methods of debugging, new ways of monitoring performance, and a much humbler approach to what these models can actually do. If we can solve the insight quality problem, agentic AI will change everything. If we can't, it will just be another expensive line item in the IT budget.

The Founder Perspective

If you are building in this space, my takeaway is simple: stop chasing autonomy for its own sake. The market is already getting tired of tools that promise the world and deliver a list of bullet points that any junior intern could have written. Focus on the hard parts of data cleaning, context injection, and reasoning verification. That is where the real moat is. Everything else is just a wrapper around someone else's API.

Read the original at MIT Technology Review →