Solving
Complex
Problems
With Data & AI.

The enterprise AI market is rushing to build complex agentic architectures. The industry fixates on frameworks like LangGraph or CrewAI, attempting to wire up APIs and create autonomous decision trees that run invisibly in the background. For most enterprise operations, this is a trap.

The promise of the autonomous agent is full automation. The reality is months of integration hell. Teams still map every business process and build APIs for legacy systems never meant to be automated. The idea that an AI will figure out the workflow autonomously is mostly a myth. The cost of an agent hallucinating a business process is too high, forcing teams to do massive analysis work upfront.

A quieter, more pragmatic shift is happening that represents the actual future of work: AI Browsers, or desktop agents. Tools like Perplexity Comet, OpenAI Operator, Claude Cowork, and xAI Macrohard operate directly on the user interface rather than bypassing it via APIs. They see what humans see.

This copilot approach beats the black-box agent for three reasons.

Zero integration tax. Most enterprise work happens in web applications. Teams do not need to wait for IT to build an API wrapper for a fifteen-year-old ERP system. If a human can click it, an AI Browser can click it. It reuses the access and security context the operator already holds.

Humans own the flow. Traditional automation requires hard-coding logic. With an AI Browser, the human provides the logic in real time. An operator types, "Go to Order #1234, verify shipping status, and issue a full refund," and the AI handles the twenty clicks required to execute it. The human plans; the AI executes. Teams do not need to pre-map every edge case because the human sits in the loop to handle them. This democratises prompt engineering, allowing teams to naturally build a standardised prompt library from the bottom up.

Visual trust. This is the missing piece in corporate AI. When an agent runs in the background, you do not know it failed until something breaks. With an AI Browser, you watch it work. You see it navigate the CRM, cross-reference the internal portal, and draft the email. If it hallucinates, you stop it. The feedback loop is instant.

The current limitation is speed. AI Browsers are slower than skilled humans clicking through screens. But as models advance and inference is optimised, they will soon click buttons as fast as any human. Within two years, the AI Browser will be a standard productivity tool expected of every office worker.

The goal is not to build faster flowcharts. It is to build tools that allow one person to do the work of ten. The future of enterprise AI is not a headless bot in a server room, but a browser that clicks for you.

Building an LLM chatbot is deceptively easy. You write a prompt, wire up an API, and suddenly it talks back. It feels magical. But knowing whether it works consistently, safely, and helpfully is an entirely different engineering challenge. Relying on subjective vibe checks is the fastest way to build unreliable software.

Evaluation metrics are not an afterthought. They are the engineering backbone of the entire system. Without them, you are simply gambling with probabilistic text. The critical shift occurs when teams move from manual testing to a systematic evaluation framework. This does not mean building complex dashboards on day one. It starts with a simple Golden Test Set — a collection of real, messy inputs that define what good looks like for your specific domain.

We find immense value in Critique Shadowing, a concept popularised by Hamel Husain. A human domain expert reviews the AI's outputs and explains exactly why they are good or bad. You then use these detailed critiques to train an LLM-as-a-judge to evaluate outputs at scale. This creates a tight feedback loop where automated metrics align with actual human judgment, rather than chasing generic vanity metrics like toxicity scores that miss the nuance of your business.

For conversational systems, however, checking single responses is insufficient. As Lena Shakurova points out, you must evaluate the structure of the conversation. Did the bot verify the user's identity before sharing account details? Did it escalate to a human after failing twice? Teams need to test the flow, not just the text. This requires simulation — spinning up user personas to roleplay scenarios against the bot, uncovering edge cases no manual reviewer would find.

The goal is not simply to find bugs. It is to unlock a reliable feedback loop. When you have robust evaluations, you can ship prompt updates with confidence, knowing you have not silently broken a critical feature from three months ago. It turns anxiety-inducing deployments into routine updates.

Further reading

• Lena Shakurova — Evaluating LLM-based chatbots: A framework for reliable AI assistants
• Hamel Husain — Your AI Product Needs Evals
• Hamel Husain — Using LLM-as-a-Judge
• Hamel Husain — A Field Guide to Rapidly Improving AI Products

A growing narrative suggests that websites may soon be obsolete. If an LLM can generate an interface on the fly or execute a task automatically, why visit a URL? The argument sounds convenient, but convenience without alignment is dangerous.

We see the results when teams blindly trust AI automation. Trading bots lose portfolios because they follow instructions too literally. The gap between doing what the user said and doing what the user meant is exactly where money and trust are lost.

This is why the AI Browser model — rather than the autonomous backend agent — represents the inevitable future of enterprise work. And it means SaaS and websites are here to stay.

Trust requires transparency. You cannot trust what you cannot see. If an agent executes a task via a backend API, it is a black box. You only know it failed when you see the loss. With an AI Browser, the execution happens on the user interface. You watch the bot click, scroll, and type. You can verify the information because you look at the same source of truth. The graphical user interface is the only shared language between human and AI that preserves accountability.

Humans are creatures of habit. Real-time generative UI, where an AI builds a custom interface for every interaction, is a UX nightmare. Humans rely on muscle memory. We need to know exactly where the buy button sits. If the interface shifts every time we log in, cognitive load spikes. We need stability to remain effectively in the loop.

The accountability gap. Why do companies still need websites if a foundational model knows everything? Because the model is not liable for your refund policy. A generated answer from a third-party LLM is not an official response. The company website remains the legally binding source of truth.

SaaS is not going anywhere. It will become even more critical as the stable, verifiable anchor in a world of probabilistic AI. But the frontend is about to pull double duty. Historically, teams designed for one user: the human. Now, they must design for two: the human and the AI Browser.

This means optimising for machine readability alongside human usability. The good news is that machine-friendly principles — clear navigation, explicit error messages, accessible data structures — are also excellent UX for humans. Can an AI agent navigate your sitemap in two clicks instead of ten? Are your error messages clear enough for a bot to self-correct? Is your critical data trapped inside unreadable canvas elements or dynamic pop-ups?

The future is not about replacing software with chat bubbles. It is about building software that both humans and their AI copilots can use together.

The drive to over-engineer AI agents for enterprise automation is often a trap. The root cause goes deeper than integration headaches. It stems from a fundamental mismatch between the tool and the task: we are trying to use a probabilistic engine to solve deterministic problems.

As Andrej Karpathy noted, LLM neural nets are optimised for imitating human text and collecting reward signals, not for flawlessly executing rigid business logic. They are prediction machines built to guess the next most likely token. This architecture makes them incredible at tasks where there is no single right answer, such as creative writing, brainstorming, summarising messy data, or exploring a codebase.

However, most enterprise workflows are binary. While there might theoretically be multiple ways to achieve an outcome, there is usually a strictly limited number of acceptable methods. This is driven by legacy constraints and compliance. A refund must follow steps one, two, and three exactly, or the system breaks. In many operations, the stakes are simply too high to reengineer these rigid processes just to accommodate an AI's need for flexibility.

When teams build autonomous agents to handle these rigid processes, they fight the model's fundamental nature. They spend months building elaborate guardrails, validators, and retry logic just to stop the model from acting like a model. They attempt to beat the probability out of the system.

This does not mean organisations should avoid agentic AI. It means we must deploy it against the right use cases. We should place LLMs where they thrive:

• Exploratory Tasks: Analysing the last five support tickets to understand why a user is frustrated.
• Creative Work: Drafting a polite, context-aware apology email for a delay.
• Code Generation: Instead of asking the LLM to act as a calculator, asking it to write the calculator.

That final point is the sweet spot for enterprise AI. If you need a deterministic result, do not ask the LLM to execute the logic directly. Ask it to write the code that executes the logic. This delivers the flexibility of natural language input alongside the execution safety of compiled code.

Until foundational models reason with much higher reliability and alignment, the most effective architecture remains clear: use LLMs to navigate ambiguity, but let code handle the execution.

When Anthropic launched Claude Cowork plugins for sales, finance, and legal operations, software stocks took an immediate hit. Major platforms like Thomson Reuters and LegalZoom saw sharp drops as the market adopted a rapid narrative: AI agents are replacing SaaS.

We believe the market has this backwards. We saw the exact same pattern during the DeepSeek sell-off, when Nvidia lost nearly $600 billion in a single day. The assumption was that cheaper AI models meant less demand for compute. A year later, cheaper models actually drove massive increases in AI usage, and Nvidia briefly became the first $5 trillion company. Lower costs created more adoption, not less.

The same logic applies here. AI tools do not replace SaaS. They make SaaS platforms more important.

Automation has to happen on something. An AI agent can draft a complex contract, but that contract still needs to live in a secure system of record. An agent can process a refund, but that transaction still needs to flow through the same payment gateway, the same ERP, and the same CRM. The underlying SaaS tool is the necessary surface where the work gets done, regardless of whether a human or a bot is clicking the buttons.

Crucially, the human still needs to verify the work. Trust requires transparency. If an agent calls an API behind the scenes, operators have no idea what it actually did until something breaks. But if the agent operates on a visible interface, humans can watch, verify, and intervene immediately. That verifiable interface is the SaaS product.

As long as humans remain in the loop — and they will for the foreseeable future — the frontend matters deeply. The AI agent does not technically need a frontend to perform actions, but the human supervising it absolutely does.

What will change is how SaaS companies monetise. Selling per-seat licenses becomes less relevant when one person, augmented by AI, can do the work of ten. But the volume of work flowing through the platform increases. Pricing models will shift toward value: per process, per output, or per result. The revenue model evolves, but the core product remains.

If anything, AI makes SaaS ecosystems more complex, not simpler. Teams can now automate workflows that were previously too expensive or tedious to build out. More automation means a heavier reliance on the tools that execute it, not less.

SaaS companies that adapt their pricing and optimise their interfaces for both human operators and AI browsers will emerge from this transition significantly stronger. The category itself is not going anywhere.

Further reading

• The Website Isn't Dead. It's Just Getting a New User.
• We Are Over-Engineering AI Agents
• Anthropic's new AI tool sends shudders through software stocks