Agents are replaceable. Your business logic isn’t.
As enterprises race to put agents to work, the most valuable thing they own is quietly being rewritten to fit whichever model runs it. Why the definition of how your business runs should never live only inside the agents that run it.
By Gilad Ben-Nahum, President10 min read
In short
- As AI agents are being increasingly deployed and upgraded, the core business logic behind the operation is getting buried in prompts and workflows.
- When enterprises migrate to a new model or switch providers, they run the risk of having to reconstruct the underlying rules that enable their businesses to tick.
- The solution does not lie in halting agent adoption but rather in maintaining ownership of your business logic, independent of the technology executing it.
Every enterprise putting AI agents to work is running the same project, whether it calls it that or not: reconstructing its own business logic.
The goal is efficiency. A discovery team sits down with the people who run a process and captures how the work really gets done. Some of it lives in policy and procedure. Some lives in systems: fields, validation rules, a workflow someone configured years ago. And a great deal lives in people’s heads: the exception handled by calling one specific colleague, the vendor everyone double-checks, the threshold that is officially one number and practically another.
That logic is fragmented and often contradictory, and the team must decide what should happen.
There’s something everyone in that room understands and few say out loud. The point is for agents to carry more of the work. Some of the people describing the process today may be in different roles tomorrow, or at different companies. The knowledge they’re handing over may not have another home.
So where does that logic go once it’s captured?
Where the logic actually ends up
In many deployments today, the answer is: into the agents.
That isn’t a criticism of anyone. It’s the natural path. A builder, whether an internal AI team, a deployment partner or a platform’s forward-deployed engineers, breaks the process into tasks and builds agents to perform them. Each agent gets instructions, context, examples, tool definitions and guardrails. Then comes the iteration. The output is close but not right, so the prompt is adjusted. The model handles an edge case poorly, so a workaround is added. Another model behaves differently, so the phrasing changes again.
Eventually, the agents work. And the business logic now lives somewhere it didn’t before.
It’s spread across many agents; ten or fifteen for a single process is not unusual. Each holds a slice of the knowledge, the task and the definition. No individual agent necessarily holds the whole. And each slice has been tuned to whichever model it was tested on, rather than written in the business’s own terms. A rule like “escalate any invoice above the approved variance” might now exist as a sentence in one prompt, an example in another, a tool description in a third, and an unstated assumption in how a fourth agent was tested.
The process runs. But ask “what exactly is our rule for this, end to end?” and there may be no single, authoritative place to look.
You’re not trapped. You’re paying the migration tax.
None of this hurts on day one. It hurts the first time you want to do more with what you’ve built.
And you will, constantly. Improve accuracy where agents still make mistakes. Test a newly released model. Optimize cost by routing routine volume to a cheaper one. Switch providers because pricing, terms or capabilities moved. Expand to a new region, business unit or product line. Change a rule because a policy or a regulation changed. Or simply understand why the system made a particular decision.
Some changes won’t even be your choice. Model providers publish retirement schedules, and the windows can be short: one flagship model released in May 2025 was retired in June 2026, about two months after its retirement was announced.4
You can still make these changes. The question is what each change costs.
Anyone who has lived through an ERP or CRM migration knows the pattern. The expensive part was never the new system. It was digging the business logic out of the old one, where it had been buried in custom code and configuration for years, and rebuilding it. Agents repeat that pattern with one difference: the old system might have remained in place for a decade, while models can change every few months.4
Researchers saw a version of this coming. In 2015, a Google team led by D. Sculley described machine learning systems so entangled that changing anything changes everything, and warned that this kind of hidden debt compounds silently.1 Agents built on tuned prompts can inherit a similar problem: a model change may ripple through agents tuned for the previous one.
Enterprise leaders are feeling it. In a 2025 survey of 100 CIOs, Andreessen Horowitz found that agentic workflows were making it harder, not easier, to switch models, because of prompts and guardrails tuned to one model, multi-step dependencies and quality assurance that is hard to repeat. As one leader put it, changing models “can take a lot of engineering time.”2
Some projects change course entirely; Gartner expects more than 40% of agentic AI projects to be canceled by the end of 2027.3 But success creates as many reasons to change as failure does. And by the time you need to change, the people who could have explained the rules may have moved on.
One of the less obvious risks isn’t that agents fail. It’s that they succeed in a way that quietly transfers custody of your most distinctive asset.
Your business logic is part of what makes you different from your competitors: how you price, approve, prioritize, escalate and serve. Losing your grip on it isn’t just a technical-debt problem. It’s a strategic one.
“But the logic has to be tuned to the model”
The strongest objection deserves a direct answer, because it’s partly right. Models differ. Instructions that work well on one underperform on another, and production-grade results require tailoring.
There’s evidence behind this. Researchers studying how prompts transfer between models have found that a prompt engineered for one model often performs substantially worse on another than a prompt built for that model, a problem they call model drifting.5 Even formatting matters: researchers at the University of Washington and the Allen Institute for AI found that changing nothing but a prompt’s format shifted one open-source model’s accuracy by as much as 76 points.6
But notice what fails to transfer: the instructions. The objection blends two things: what the rule is, and how a given agent is told to follow it. “Invoices over the approved variance need a second approver from finance” is a business rule, true no matter which model reads it. The wording that gets a particular model to apply it reliably is an implementation. They have different owners, different lifecycles and different reasons to change.
Keep them apart and tuning still happens, but against a stable definition of what “correct” means. If instructions don’t travel between models, that’s the strongest reason to make sure the rules underneath them can.
A related objection: “We already keep our prompts in version control.” That’s good engineering, but a library of prompts is still a library of implementations. It answers “what did we tell the agent?” not “what does the business require?” The business requirement should survive a model change, even when the instructions need to be rewritten.
The logic decides what. The agent decides how.
Once the rules sit outside the agents, roles get clearer. Agents do what they’re genuinely good at: interpreting messy inputs, orchestrating steps, gathering data from many systems and executing. The business logic defines what’s correct, what’s allowed and who decides when the rules run out.
The boundary isn’t perfectly clean, and pretending otherwise would be a mistake. Deciding which rule applies is itself interpretation: is this email a complaint or a question, is this invoice within variance? That judgment stays with the agent. What changes is that its interpretation can be checked against a definition it doesn’t control. If the definition of correct lives inside the agent being evaluated, you’re grading the student with a rubric the student wrote.
The industry is moving the same way on oversight. Gartner predicts that guardian technologies, which oversee and constrain agents from the outside, will account for 10 to 15% of the agentic AI market by 2030.7 Control that lives only inside the thing it controls may not provide sufficient independent oversight.
“Isn’t this just a rules engine?”
Fair question, and the history is worth learning from. Business rules engines promised the same separation decades ago. In a 2009 critique, Martin Fowler observed that the pitch of business people maintaining rules themselves rarely worked out, and that rule systems were easy to set up but hard to maintain, because nobody could follow the implicit flow.8
Three things are different now. First, some business logic can now be expressed and maintained in the language the business uses, without requiring every rule to be translated into an engineer’s notation. In a related piece, Fowler argued that the sweet spot is logic business people can read, even when programmers write it.9 Second, old engines had to encode every path, because nothing else could handle messy reality. Agents now absorb the mess; the logic only has to define what’s correct, allowed and escalated. Third, the maintenance burden that sank many rules projects doesn’t disappear when logic is buried in prompts. It just becomes invisible. Better to carry it where you can see it.
What it means to own your logic
Owning your business logic doesn’t require a particular product or architecture. It shows up in a few practical properties.
You can read it whole. Someone accountable for the process, not only the engineer who built the agents, can see the full set of rules, thresholds, exceptions and escalation paths in one coherent view, in business language, rather than as the sum of many agents’ parts.
It survives a model swap. If you replaced every model and agent tomorrow, a separately maintained definition of how the process should behave could remain intact. You’d be re-implementing, not re-discovering.
It stays current. A specification written during discovery and filed away goes stale. Owned logic is maintained like any critical asset: you know who may change it, how a new version is approved, and which version was in force when a decision was made.
You can tell whether it was followed. Not by asking the agent, but by checking its decisions against the logic and showing afterward which rule applied. No system built on probabilistic models comes with a guarantee. This is how you get evidence instead.
It captures judgment, not just rules. This isn’t about forcing every decision into rigid if-then statements. It’s about writing down what good judgment looks like, where it applies and who decides when the rules run out. That’s also a practical way to honor the expertise of the people who shared it.
Let agents compete. Keep the logic constant.
Once business logic is a stable reference that agents work against, you can run a real A/B test: two models, two agent designs, two vendors, even a human team against an agentic one, all measured against the same definition of correct. The same ICLR 2024 study found that how well a prompt format works only weakly carries over from one model to another, which undermines comparing models on a single fixed prompt.6 In practice, many comparisons quietly test two interpretations of the process at once.
You can also optimize continuously. Route routine cases to a cheaper model, try a new framework on a slice of volume, and measure what changed, because the yardstick didn’t move. Your choice of model or platform becomes a decision you keep making on merit, not one you made once.
It also changes who sets the bar. Whoever builds your agents, whether an internal team, a systems integrator or a platform, becomes interchangeable, judged by your definition of correct rather than their own. Your business logic becomes the basis for the acceptance criteria every agent has to meet, and you still own the job of keeping that definition right. That shift deserves its own piece, and we’ll cover it in a follow-up post.
This isn’t an argument against agents, or against the platforms and partners who build them. The value of agentification is enormous and still largely uncaptured. It’s an argument about custody. Whatever you build, and with whomever, the definition of how your business works should stay in your hands.
Five questions before your next deployment
- If our current model were retired next quarter, would we be re-implementing this process or re-discovering it?
- Where can the person accountable for this process read its full logic, end to end, without opening a prompt?
- When a business rule changes, how many agents need editing, and how would we know we found them all?
- When we compare two models or vendors, are we testing them against the same definition of correct?
- If the people who explained this process to us left tomorrow, would their knowledge still be ours?
Agents will keep getting better, cheaper and more capable, and the models behind them will keep changing. The open question is whether, when they do, you’ll still know exactly how your business is supposed to run.
If you had to replace every agent you run tomorrow, how much of your business logic could you take with you?
Sources
- D. Sculley et al. (Google), “Hidden Technical Debt in Machine Learning Systems,” NeurIPS 2015. Paper
- Andreessen Horowitz, “How 100 Enterprise CIOs Are Building and Buying Gen AI in 2025,” June 2025, section 10. Report
- Gartner, “Gartner Predicts Over 40% of Agentic AI Projects Will Be Canceled by End of 2027,” June 25, 2025. Press release
- Published model retirement schedule of a major model provider (deprecations and retirement dates, 2025–2026). Schedule
- Y. Wang et al., “PromptBridge: Cross-Model Prompt Transfer for Large Language Models,” arXiv 2512.01420, December 2025 (preprint). Paper
- M. Sclar, Y. Choi, Y. Tsvetkov, A. Suhr, “Quantifying Language Models’ Sensitivity to Spurious Features in Prompt Design,” ICLR 2024. Paper
- Gartner, “Gartner Predicts that Guardian Agents will Capture 10–15% of the Agentic AI Market by 2030,” June 11, 2025. Press release
- Martin Fowler, “Should I use a Rules Engine?” (RulesEngine), 2009. Article
- Martin Fowler, “Business Readable DSL,” December 2008. Article