The best AI assistant is the one you don't have to explain everything to

If you have to tell an AI assistant which company you're working on, which budget you're looking at and which line you want analysed, someone has already done a poor job with the integration.

We've become used to artificial intelligence starting with an empty text box. We type a question, add background information, perhaps upload a document and try to phrase ourselves as precisely as possible, and if we get a poor answer, we try again with a better prompt. That works well for many tasks, but I think it's a poor starting point when AI is to be integrated into professional business systems.

If I'm working on a budget, the application knows which company I'm in, which period I'm looking at, which numbers I'm working with and which part of the budget has my attention. Asking me to repeat that in a text box isn't intelligent interaction. It's a sign that too much of the integration work has been pushed onto the person.

Context isn't a prompt. It's architecture.

Let's use budgeting as an example. A business leader is working on the 2027 profit and loss budget and is considering increasing payroll costs by 15 percent. That might be due to planned hires, pay adjustments or a combination, and the question is whether the increase makes sense given the company's expected development. A general AI service can offer interesting reflections, but first it has to be told what the company does, how many employees it has, what current payroll costs are and what the growth expectations are based on. In a financial system, much of this is already known. The challenge, then, isn't getting the user to phrase a better question, but making sure the system gives the AI the right basis for answering it.

At Capassa, we've chosen to make the interaction as simple as possible: You right-click a budget line and ask Capa to analyse the number. The interesting part isn't the right-click, but what happens between the action and the answer. The application identifies what the user is actually asking for, which data is relevant and how it should be presented to the model. It distinguishes between a single line and a subtotal and knows how the subtotal is built up from account groups, it understands the period being analysed, and it doesn't treat a monthly cost as an annual cost. If the user is working with a scenario, the analysis is based on that scenario and isn't mixed up with another budget. Details like these may seem trivial, but this is where financial analyses become either useful or misleading, and they're solved through software architecture, not by hoping a language model guesses its way to the context.

That's also why I don't think it's enough to put AI as a chat interface on top of existing software without having dealt with context and calculations. A chat can be a fine supplement, but if it's the only way in and the user still has to find the information and explain the relationships, we haven't come very far. There's a difference between data access and working context: An agent can have access to enormous amounts of information without understanding what the user is trying to achieve.

More information isn't the same as better insight

A common misconception is that the model gets better the more we give it. If a company has tens of thousands of transactions and the question is about payroll costs, it rarely makes sense to send them all to a language model and ask it to work out what's relevant. That means larger volumes of data, higher costs and more to sort through, and even more importantly: We hand a probabilistic model tasks that ordinary software components solve more precisely. A language model shouldn't be used as an expensive calculator. If payroll costs go from eight to 9.2 million kroner, we don't need AI to work out that it's 15 percent. Comparing budget with actuals, margins and subtotals of account groups should be done with ordinary, verifiable calculations. I've written more about this in AI can give a perfect answer. Based on the wrong numbers.

The language model's strength is interpreting the results, identifying what deserves attention and helping the user understand which questions to ask next. An increase in payroll costs can make perfect sense if it supports a realistic growth plan, and be a warning sign if revenue isn't expected to grow accordingly. To assess that, the model needs quality-assured numbers and enough information about the context they belong to. The software should handle data, access control, definitions and calculations. The AI should use that foundation to analyse, explain and challenge.

Let the software calculate. Let the AI reason.

AI also needs to know what it shouldn't have access to

When we talk about context-aware agents, it's easy to focus on how much information they should get. At least as important is what they shouldn't have. A user working with one company shouldn't be able to access data from another. An analysis of a budget doesn't require insight into every underlying voucher. And if an agent is to explain a key figure, the definition and the basis of calculation have to be known, so the result can be verified. This can't be solved with an instruction telling the language model to be careful. Access control, data selection and validation have to be enforced by the systems around the model, and the AI should neither decide what the user is allowed to see nor check its own calculations without an independent basis. OWASP's top ten for agentic applications addresses exactly these kinds of risks, including tool misuse and overly broad access.

In financial systems this is especially important, because mistakes can have major consequences. An answer that sounds reasonable can influence decisions about investments, staffing and financing, and then it isn't enough that the model is usually right. We need to be able to understand where the numbers come from, what the analysis is based on and where the limits of the conclusion lie.

The best technology is the one that gets out of the way

I think we'll see a clear divide between two kinds of AI solutions. On one side we'll get software that has gained an AI box where the user can ask questions, and on the other, systems where AI is integrated into the work process itself and offers relevant help when the need arises. The first is easy to demonstrate. The second is harder to build, because it requires us to understand the subject area, the data model and the tasks the user actually performs.

For a business leader preparing next year's budget, the goal isn't to have a conversation with a language model, but to understand whether the business can afford to hire more people, whether the growth assumptions are realistic and what happens to liquidity if plans don't turn out as expected. For a CFO, it's about a better basis for decisions with less manual work, and for an accountant, it's about more time to help clients with the financial choices they face. We talk a lot about how intelligent AI models have become. I think we should spend at least as much time discussing how intelligently we build the software around them.

The best AI assistant isn't the one you can ask about everything. It's the one that understands what you're working on, and can help you without you having to explain everything first.