How much AI does your project really need? The four levels of autonomy

The problem: "Let's add AI"

Recently we've often heard the same question, phrased more or less the same way: "Can we add AI?"

It's a legitimate question, because it comes from a solid intuition: today, with advances in AI and falling costs, automating business processes that used to take days now takes hours, and has become accessible to everyone, representing a huge competitive advantage.

The first and most useful question to ask, however, is: how much AI does this really need (i.e., how "big" is the task I need to do or outsource)? Sometimes traditional software is enough; sometimes a well-trained AI assistant does the trick; and sometimes you need a system that reasons, makes decisions, and acts on its own (AI agents).

The honest answer can only be given case by case, and it shapes implementation costs, methods, and ease of use. So it's always worth asking.

Choosing the wrong approach from the start often means building something that's too complex, too expensive, or too unreliable. In fact, there are two opposite mistakes we often see: on one hand, some people hand AI a task that a rule written once would have solved for good, and end up with a tool that costs money every time it runs and occasionally makes mistakes precisely where they can't afford it. On the other hand, there are those who commission months of development for software that could have been achieved in a week by properly training an AI assistant.

In between, there are solutions that work. There are four of them, and it's worth knowing what they are before signing a quote.

Before you choose: rules and probabilities

To make a good choice, you need to keep one distinction in mind, and we promise this is the only slightly technical part of this article, but it will help you better understand what follows.

There are tools that perform automations simply by following precise, pre-set rules. Think, for simplicity's sake, of Word's "Find and Replace" feature: you search for an old product name, type in the new one, and it swaps it on every line of the document. Never one too few, never one too many. If you run it a hundred times, you'll get the same document a hundred times. Examples you use every day: your business management software, your spreadsheet with formulas, the software that issues your invoices.

Then there are tools that work on probabilities (increasingly accurate, but still "predictions"). A very simple example is your phone's text predictor: type "how are," and it suggests "you," because statistically, that's the word that follows most often. It's usually right, but it can get it wrong every now and then.

So, to put it very simply, LLMs like ChatGPT and other models work on this principle: they don't follow a list of rules written by someone, but generate the most likely result based on what they've learned. They're very good at interpreting language, images, and unstructured information, but they remain probabilistic systems. The more a task requires interpretation, the more useful they become. The more it requires absolute precision, the more they need to be paired with rules and checks.

Everything that follows comes down to exactly this distinction: working out which parts of a process must be 100% predictable and which, instead, require the ability to interpret.

Or, to put it another way: who should make the decisions? Because that, fundamentally, is what sets apart the main ways of building a system with AI. Let's look at them.

The four levels of autonomy

1. Traditional software: when the rules decide

This is what you're already familiar with: the management software, the portal, the app you use every day. You provide input, and you know exactly what it will get back.

You don't want software that occasionally gets an invoice total wrong or miscalculates a due date. These tasks require absolute predictability. This is precisely the advantage of rules: they cost time and money to build, but once they're in place, they run reliably and cost very little to use.

What's interesting is that AI has become very good at building exactly this kind of software. When the problem is clear and the result can be verified, AI can help write, test, and fix the code far faster than before. That means some software that wasn't economically viable in the past can now become a reality.

When does this make sense?

When the process is predictable, repetitive, and requires precision.

Some examples:

• order management;
• billing;
• financial calculations;
• database updates;
• administrative processes.

Here, AI can help build the system, but it does not necessarily have to live inside it.

2. The AI assistant: when the human decides

This is the simplest way to use AI. You don't build new software; you give an AI model a role, instructions, and context, right in the chat.

For example:

• an assistant that drafts your first email versions;
• a system that summarizes documents;
• a tool that analyzes market research;
• support for creating content;
• an assistant that prepares a sales proposal.

The upside is that it adapts: it understands requests you hadn't anticipated, connects ideas, and improves over time. The downside is the flip side of the same coin: the answer is never quite the same twice, sometimes it misreads the context, sometimes it makes things up. For a text you'll review, that's perfectly fine. For a number that ends up in a quote, much less so.

It's also the cheapest route to take: often all you need is a subscription to a model like ChatGPT or Claude, plus the time to train the assistant well.

When does this make sense?

When the task requires interpretation, creativity, or language, but a person still needs to check the result.

3. The AI copilot: when rules lead and AI interprets

This is where it gets interesting, because you combine the reliability of the first approach with the interpretive ability of the second.

The principle is simple: the rules decide the process, and AI steps in wherever understanding is needed.

Think of accounting software that reads photographed receipts (that takes interpretation, so AI) and then logs them to a database and generates the reports (that takes precision, so rules). Or a tool that creates the images for your social profiles, while an automation layers the logo, prices, and text on top, pulling them from a list you wrote yourself.

The detail that matters is who's in charge: the rule-based process leads, and it calls on AI only at set points, to do one specific thing. AI never decides what happens next.

More examples:

• a customer service system that sorts requests and routes them to the right team;
• an HR tool that screens CVs but applies selection criteria defined by the company.

When does this make sense?

When you need automation, but some parts of the process require typically human abilities.

4. The AI agent: when AI decides what to do

The last level is the one everyone's talking about right now: agentic AI.

There's just one difference from the previous cases, but it changes everything. You don't tell the AI exactly what to do; you give it a goal. Then it's up to the AI to decide which tools and rules to use to reach it.

Think of an agent handling a quote request: it receives an email from a potential client. The agent:

• reads the request;
• works out the type of need;
• pulls information from the CRM;
• checks the price list;
• prepares a proposal;
• verifies whether any information is missing;
• generates the document;
• gets it ready to send.

No one wrote it a rigid sequence of instructions. It was given a goal (and all the context), and it decides which steps to take. Conceptually, it's a lot like a small team of people using their own judgment and their own tools to reach a result. It's exactly how we built the system that runs the Meta Ads campaigns we told you about: an assistant that analyzes, proposes, produces the creatives, and then loads everything in paused mode, waiting for your go-ahead.

When does this make sense?

When the process is complex, involves multiple tools, and requires constant adjustments.

How to choose

There are many possible combinations, and they all have their strengths and weaknesses. The general rule is that rule-based software costs more to build but little to keep running, while the more AI-heavy solutions are quick and cheap to build but carry an operating cost that comes back every month.

That said, here's how we think it through when we have to decide:

• Rules only, when you need a system that's predictable, stable over the years, and cheap to run. Just factor in that building it, changing it, and maintaining it costs money.
• AI only, for repetitive tasks that need a bit of interpretation or creativity. The cost is roughly that of a subscription, and you improve it by talking to it.
• Rules with AI on call, when you need a predictable system that also has to handle the odd "human" task, like writing a text or pulling a figure out of a photo. It costs money to build and to keep running, in proportion to how much AI passes through it.
• AI in charge, when you need a system that moves across different tools and can do several things. It's faster to build than traditional software, but it takes both technical skills and someone who truly knows the trade the system is meant to perform.

One last, very important, thing

If we had to sum it all up in a single line: in most projects, the winning solution is the one where AI does only what the rules can't, and nothing more.

We're not being cautious as a matter of principle, it's simply what we've seen work most of the time. Every piece of a process you hand to AI for no reason is a piece that costs money every time it runs, that might give you a different answer tomorrow, and that you'll have to check by hand. Every piece you hand to the rules, you write once and stop thinking about.

The hardest part is figuring out where the line falls in your specific case. And that depends on how you work, not on whichever model is trending this month.

👉​ Have something in mind and aren't sure which of the four ways it should be built? Write to us and book your free consultation call directly with us. Choosing well at the start costs a conversation; discovering the mistake halfway through costs redoing the work.

Talk soon, Alice & Cesare, Akme