AI automation is often presented as a simple formula: connect a powerful model to your business systems, give it access to the right tools, and let it handle the work.

That can produce an impressive demonstration. It does not always produce a dependable business system.

At Smartt, we have found that some of the most effective AI automations use less AI than people expect. Instead of asking a language model to make every decision, we often use conventional code to handle predictable work, AI to review performance and interpret exceptions, and people to approve meaningful changes.

This may sound less exciting than handing everything to an “autonomous agent” that everybody is talking about on YouTube. But in practice, it usually produces better results. The systems we build this way become more consistent, easier to understand, less expensive to operate, and safer to improve over time.

Not Every Task Requires Intelligence

Many business processes contain a mixture of predictable and unpredictable work.

Consider a system that monitors a stream of customer messages, market alerts, service tickets, transactions, or operational data. Some parts of the process may require judgment, but much of the underlying work is mechanical.

The system may need to:

• collect information from a known source;
• convert it into a consistent format;
• remove duplicate records;
• check for specific words or values;
• compare results with established thresholds;
• route records into predefined categories;
• store information in a database;
• trigger alerts when a known condition occurs.

None of those tasks necessarily requires a frontier AI model.

They can often be handled more reliably with rules written in Python, JavaScript, or another conventional programming language. Once those rules are tested, the system will apply them in the same way every time.

That consistency is valuable, and arguably, actually mission-critical for most businesses. Afterall, if the same input enters the system twice, the business generally expects the same result twice. A probabilistic model may not always behave that way, especially when the prompt is complicated or the input contains ambiguity.

The first question in an AI automation project should therefore not be, “Where can we add AI?”, but “Which parts of this process genuinely require judgment?”

Pure AI Workflows Can Be Hard to Trust

Large language models are extremely capable, but they do not behave like ordinary software.

Traditional code follows explicit instructions. If a value exceeds a threshold, a rule can trigger an alert. If a required field is missing, the system can reject the record. The result is usually predictable and traceable.

AI models interpret. This strength is also their Archille’s heel because it creates inconsistency. A model may classify similar inputs differently, overlook a detail it identified correctly the day before, or place too much weight on wording that is not important to the business.

And the more responsibility the model receives, the harder the workflow can become to test.

This matters when an automation is processing real business activity every day. A result that is “usually right” may be acceptable for brainstorming. It may be unacceptable when the system is changing customer records, escalating security events, publishing content, or influencing financial decisions.

Pure AI workflows can also be difficult to debug. When a conventional rule produces the wrong result, a developer can inspect the logic and identify the cause. When a model makes an unexpected decision, the explanation may be less clear. The problem could come from the prompt, the model, the context, the input formatting, a tool call, or simple variability between runs.

For an enterprise, clever is not enough. (The system must also be understandable.) And this is probably why so many AI projects fail.

AI Can Help Write the Rules

Using less AI inside the daily workflow does not mean using less AI to build the system.

In fact, AI has become one of the most useful tools for creating conventional automation.

We regularly use models to help generate Python and other code based on clearly defined business rules. AI can help translate a process into functions, build integrations, normalize data, develop test cases, document the logic, and identify edge cases a developer may not have considered initially.

Models such as Sonnet or earlier Opus releases can be excellent for focused implementation. They can write scripts, build features, work with APIs, and solve well-defined technical problems quickly. More advanced models like Fable and Sol can then review the result.

Opus 5 or GPT-5.6 Sol, for example, can inspect the code for weaknesses, identify missing cases, improve its structure, debug failures, and explain the solution in terms that business stakeholders can understand.

Fable can help orchestrate a larger project by breaking it into stages, coordinating dependencies, and keeping the work moving across multiple steps.

The AI does not need to remain inside every transaction to create significant value. It may create enormous value by helping design and improve the machinery that performs those transactions.

Let Rules Run the Business

Once the automation is operating, predictable work should generally remain predictable.

A rules-based system can process information continuously using logic the business has already approved. It can do so quickly and at a low incremental cost.

For example, a monitoring system may apply rules such as:

• ignore records from known test accounts;
• normalize common abbreviations;
• flag messages containing a specific combination of terms;
• assign a higher priority when several conditions occur together;
• suppress duplicate alerts within a defined period;
• store every decision and the rule that produced it.

These rules can be reviewed, tested, versioned, and audited.

If the business decides to change a threshold, the change can be documented. If a false positive occurs, the team can trace exactly which rule caused it. If the system is updated, the old and new versions can be compared against the same historical data.

This creates confidence that is difficult to achieve when every decision is generated fresh by a model.

The system may appear less magical, but it is often more useful.

Use AI for the Work Rules Cannot Handle Well

Rules are effective when the business knows what it is looking for. They are less effective when meaning depends on context.

That is where AI becomes valuable: A model can review information that does not fit neatly into a fixed category. It can detect emerging patterns, summarize complex activity, interpret unusual language, identify possible relationships, and explain why a set of results may deserve attention.

A hybrid automation might therefore use deterministic code for the majority of daily processing and send only selected cases to AI.

Those cases might include:

• inputs the rules could not classify confidently;
• unusual activity outside normal patterns;
• records containing conflicting signals;
• new language the system has not encountered before;
• high-value cases where additional interpretation is worthwhile;
• a daily summary of what changed and why it may matter.

This approach gives the business the benefit of AI without paying for AI to repeatedly make decisions that could have been handled by a simple rule.

It also reduces risk. The model focuses its attention on ambiguity and exceptions rather than controlling the entire process.

Review the System, Not Just Each Transaction

One of the most promising uses of AI is not making every operational decision. It is reviewing how the overall system performed.

At the end of each day, an advanced model can examine the results produced by the rules-based automation.

It can look for questions such as:

• Did the system miss any important cases?
• Did one rule produce too many false positives?
• Are users expressing the same idea in a new way?
• Did a new pattern appear that the current rules do not cover?
• Are some alerts repeatedly ignored because they are not useful?
• Should a threshold be increased or decreased?
• Did an external change reduce the accuracy of an existing rule?

The model can then recommend improvements.

A person reviews those recommendations, decides which ones make business sense, and approves any change to the operating logic. The updated rules can be tested against historical data before they are deployed.

This creates a continuous-improvement loop:

Rules execute the process. AI reviews the results. Humans approve the improvements.

The automation gets smarter over time without becoming unpredictable.

Human Approval Is a Feature, Not a Failure

There is a tendency to view human involvement as evidence that an automation is incomplete.

We disagree because in many business systems, human approval is what makes greater automation possible. When a person reviews changes to important rules, the organization retains accountability. Someone can ask whether the proposed improvement reflects the real business objective, whether it introduces a new risk, and whether the data supports the change.

This is especially important when the automation affects customers, security, finances, legal obligations, or the company’s public reputation.

AI can make a recommendation, but should not automatically redefine the rules governing the business simply because it noticed a pattern.

The right amount of human involvement depends on the consequences of error. A low-risk internal categorization tool may operate with very little oversight. A system that sends payments or changes customer access should require much stronger controls.

Basically, instead of maximum autonomy, we want to worry about the “right level” of autonomy. (We used to tell clients “do the right things right”. Now we say “Automate the right things, with the right level of autonomy.”)

The Cost Difference Can Be Significant

A system that sends every record to a frontier model may become expensive as volume increases.

Each call consumes tokens, tool usage, processing time, and sometimes several rounds of reasoning. An agentic workflow may also retry tasks, call additional tools, or pass information between multiple models. For a small prototype, these costs may be negligible. At enterprise scale, they can become a material operating expense.

Conventional code can process repetitive work at a fraction of the cost. AI can then be reserved for high-value interpretation, review, and exception handling. This is similar to how a well-run company allocates human expertise. Routine work follows a documented process. Specialists become involved when judgment is needed.

Using the most advanced model for every step is inefficient resource allocation, period. In fact, using any kind of AI that deterministic code can accomplish is a waste! Save your tokens for improving your deterministic models instead.

Hybrid Systems Are Easier to Govern

Governance becomes simpler when each part of the system has a clearly defined role.

The deterministic layer handles approved rules. The AI layer interprets uncertain cases and reviews performance. The human layer controls material changes and remains accountable for the outcome.

This separation makes it easier to answer important questions:

• What decisions can the automation make by itself?
• What information is sent to an AI model?
• Which model is being used, and why?
• What happens when the model is uncertain?
• Which actions require approval?
• How are changes tested and documented?
• Can the business explain why a decision was made?

These questions become harder to answer when one autonomous agent is responsible for everything from interpreting the input to taking the final action.

A hybrid system may contain more visible components, but its responsibilities are clearer.

A Practical Example

Imagine a company that receives hundreds of operational messages each day.

A pure AI approach might send every message to a model and ask it to determine the topic, urgency, required action, and appropriate recipient.

A hybrid approach could work differently.

First, Python code collects the messages, removes duplicates, normalizes common terms, and applies established routing rules. Most messages are handled immediately because they follow familiar patterns.

Messages that contain conflicting signals or cannot be classified confidently are sent to an AI model for interpretation.

At the end of the day, another model reviews the classifications, identifies unusual patterns, and flags potential weaknesses in the rules.

A person then decides whether the routing logic should change.

The hybrid system may use AI on only a small percentage of individual messages, yet AI still contributes throughout the lifecycle: designing the code, reviewing ambiguous cases, analyzing performance, and recommending improvements.

That is what we mean when we say the best AI automation may use less AI than you think.

Build for the Business, Not the Demonstration

Autonomous agents will continue to improve, and there will be processes where giving them greater responsibility makes sense.

However, the right architecture should be determined by the needs of the business rather than the desire to make the technology appear impressive.

Businesses need systems that are reliable, economical, secure, understandable, and capable of improving over time. Sometimes the right solution is a powerful AI agent. Sometimes it is a small script. More often, it is a thoughtful combination of models, conventional software, documented rules, and human judgment.

At Smartt, that is how we approach AI automation: We use AI where its ability to interpret, create, and reason adds genuine value, and deterministic code where the business needs consistency. We also use different models for the roles they perform best, but keep people involved where accountability and judgment matter.

The future of automation is not about placing AI everywhere, but knowing exactly where it belongs. If you are working on an AI initiative in your organization, feel free to reach out and have a conversation!