We have never been here before
Three things are happening at once. Software is being written faster than ever. Flaws are being found faster than ever. And software now acts on its own, inside the systems that run the business.
Each shift alone would be big. Together, they change the job of every security leader. I talk to CISOs every week, and the question I hear most is simple: “What can I trust now?”
One thing has not changed. The way into the enterprise is still largely through web applications and APIs. Every AI-built feature and every agent action ends as an API call. That is why this post centers on APIs.
This post is my answer, based on what we see in customer environments every day.
Three shifts, all at once
Code is built at machine speed. Teams use AI to write code and ship APIs in days, not months. AI is good at making an API work. It does not know who should own an object, or which role may change a price. That knowledge lives in business rules, and those rules rarely make it into the code.
Flaws are found at machine speed. New AI models read code and probe APIs at a scale no human team can match. Defenders can use them. So can attackers. The time between shipping a flaw and someone finding it is shrinking fast.
Agents now act on business systems. AI agents call APIs, use MCP tools, and take real actions: refunds, transfers, record changes. For years, a human in the loop was the quiet control that caught odd requests. Agents remove that human.
The stack is built for known attacks
The first gap is in how we detect attacks. Almost every tool in the stack works from a library of known attacks. WAFs and NGFWs match traffic against signatures. DAST tools fire large sets of known exploit payloads and check the response. The bigger the library, the better the tool.
That model served us well in the past era. Attackers reused the same exploits, and a strong library kept you safe.
The next era looks different. An AI agent does not need a known exploit. It is patient and persistent. It probes one API thousands of ways, learns from every response, and chains small gaps into a working attack. What it finds is a zero-day in your own business logic: a flaw unique to your application, with no signature and no entry in any library.
Next-generation security has to find these unknown flaws first, and stop them when someone tries to use them.
Why current controls see nothing wrong
The second gap is in how we decide what is allowed. Over the last decade, our industry got very good at one question: who is this user? Identity, MFA and SSO are mature. The second question was never fully answered: what is this user allowed to do, on this object, in this workflow? I call this authorization debt.
Business logic attacks live in that gap. The request is valid. The token is valid. The payload is clean. A WAF sees nothing to block, and a SIEM sees a normal log line. What is wrong is the intent: user A reading user B’s account, a buyer setting their own price, an agent doing far more than its task needs.
Signatures cannot catch this. Understanding the application can: its objects, who owns them, and every path to reach them.
Discover what you actually run. Sensors on ingress and egress traffic, gateway integrations, and design-time sources like repos, CI/CD, OpenAPI and Postman find every API, including shadow and stale ones. The same view covers AI assets: providers, models, prompts, RAGs, MCP servers, tools and agents. Each agent is tied to the API calls it makes, with an owner and a review status.
How AppSentinels helps
Business logic security closes both gaps. It does not ask “have we seen this attack before?” It asks “should this happen in this application?”
At the core of AppSentinels is the Business Logic Graph. It maps every object, owner and access path across your APIs, AI agents and MCP servers. It knows which calls create an object, which read it, and which roles may change it. On that map, the platform does three things.
Discover. It finds every API from live traffic and design-time sources, including shadow and stale APIs missing from your schemas. It also finds AI assets: models, prompts, MCP servers, tools and agents. Each agent is tied to the API calls it makes, so you see what it actually does.
Test. It works like an army of pen-testers. It builds test cases for each API from that API’s own logic, not from a payload library. It creates an object as one user, then tries to reach it as another. It chains calls into workflows to find broken authorization, race conditions and abuse of business rules. These are your zero-days, found by you first.
Protect. In production, it runs alongside your WAF. It knows how your business logic should behave, so a new attack stands out the first time it runs, with no signature needed. For agents, it flags intent violations and excessive agency, and can revoke a token to stop a misbehaving agent at once.
The opportunity in this moment
Unprecedented times bring uncertainty. They also open a window that does not come often.
For twenty years, defenders played catch-up. An attacker found a flaw and used it, and only then did a signature appear. The library always trailed the attack. That lag was built into the model.
AI can change that balance. The persistence that makes an attacker’s agent effective works just as well for defense. A platform that understands your business logic can probe every API, every workflow and every agent action, all day, every day. It can find your zero-days before anyone else does. For the first time, defenders can move ahead of attackers.
The second opportunity is clarity. Agents force a question we put off for years: what is each user, and each agent, actually allowed to do? Answering it pays down authorization debt. It also gives engineering a clear map of the application, which helps them build with confidence.
The third is speed. When teams know their business logic is tested and protected, they can adopt AI-built code and agents sooner. Security becomes what lets the business move faster.
I have spent close to three decades building security products, from network security to zero trust. Every era had a moment when the old model reached its limit and a new one took its place. This is that moment for application security. The teams that map their business logic now will lead the next decade.
That is the work we do every day at AppSentinels. If you want to see what the Business Logic Graph finds in your environment, let’s talk.
Frequently Added Questions
WAFs and DAST tools rely on libraries of known attack signatures and payloads. In a business logic attack, the request is valid, the token is valid and the payload is clean. What’s wrong is the intent, like user A reading user B’s account, and no signature can capture that.
Authorization debt is the gap between knowing who a user is and knowing what that user may do. Identity, MFA and SSO are mature. Rules about what each user or agent may do, on which object and in which workflow, often never make it into the code. Business logic attacks exploit that gap.
AI agents call APIs and MCP tools to take real actions such as refunds, transfers and record changes. That removes the human in the loop who used to catch odd requests. Every agent action becomes an API call, so a flaw in an API’s business logic is now open to automated abuse.
A zero-day in business logic is a flaw that exists only in your application’s workflows, such as a buyer setting their own price. It has no signature and no CVE. Attackers’ AI agents find these flaws by probing one API thousands of ways and chaining small gaps into a working attack.
AppSentinels builds a Business Logic Graph that maps every object, owner and access path across your APIs, AI agents and MCP servers. It discovers every API and AI asset, then tests each API against its own logic to find flaws before attackers do. In production, it flags behavior that breaks that logic, with no signature needed.