💻 computer science

The CASE Framework: A Multi-Disciplinary Control Architecture for Governing Enterprise Agentic AI

The paper introduces the CASE framework, a multi-disciplinary control architecture that addresses the "Emergence Gap" in enterprise agentic AI by applying distinct governing sciences—Control theory, Adaptive systems theory, Supervisory cybernetics, and Engineering operations—to four layered problems of agency, collective emergence, human oversight, and fleet management, respectively.

Original authors: Srinivas Telukunta, Georgios Nektarios Lilis, Lucio Baron

Published 2026-08-12

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Srinivas Telukunta, Georgios Nektarios Lilis, Lucio Baron

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a robot to do your homework. If you just give the robot a fixed list of steps—like "open book, turn to page 10, read paragraph 2"—that's simple automation. It's like a toaster: you put bread in, push the lever, and it pops up. But what if you give the robot a goal, like "get me an A on this essay," and let it figure out the steps itself? That's an AI Agent. It can think, make choices, use tools, and even change its plan if things go wrong. The problem is, these agents are getting smarter and faster than the rules we have to keep them safe.

For decades, scientists have had different toolkits for different kinds of problems. Control theory is like the science of keeping a single car on the road using brakes and steering. Complex systems theory is the study of how a flock of birds or a school of fish moves together without a leader, where the group does things no single bird planned. Cybernetics is the study of how a human boss can manage a team without getting overwhelmed by too much information. And Site Reliability Engineering is the art of running massive computer systems without them crashing. The big question is: when we let these super-smart agents loose in the real world, which toolkit do we use? The answer isn't just one; it's all of them, working together.

This paper, titled "The CASE Framework," argues that we've been making a huge mistake. We've been trying to manage these new, independent AI agents using the same old rules we used for simple, predictable robots. The authors say this is like trying to fix a hurricane with a butterfly net. They propose a new four-layer system called CASE (Control, Adaptive systems, Supervisory cybernetics, and Engineering operations) to govern these agents properly.

Here is what they found and why it matters:

The Four Layers of the Problem
The authors break down the chaos of AI agents into four distinct levels, each needing a different kind of "governance":

The Individual Agent (Control Theory): This is about one single agent. Just like a thermostat keeps a room at a set temperature, this layer ensures the agent stays on its goal and doesn't drift off into weird behavior.
The Agent Swarm (Complex Adaptive Systems): When you have many agents talking to each other, they start doing things no one told them to do. It's like a crowd of people: one person sneezing is fine, but if they all start sneezing at once because of a shared smell, you have a panic. The authors call this "emergence."
The Human Team (Supervisory Cybernetics): This is about the humans watching the agents. The paper uses a famous rule called the "Law of Requisite Variety," which basically says: to control a chaotic system, your brain (or your team) needs to be just as complex and fast as the chaos itself. If the agents are moving too fast for humans to understand, the humans are useless.
The Fleet (Engineering Operations): This is the big picture of running thousands of agents at once. It's about having a safety budget, like a car's gas tank, to see how much "mistake room" you have left before you have to stop and check.

The Big Discovery: The "Emergence Gap"
The authors didn't just build a theory; they looked at real-world data to see if it holds up. They analyzed 62 documented failures of AI agents in production.

The Finding: They found that 82% of these failures weren't just one thing going wrong. They were a chain reaction. A small mistake by one agent (Layer 1) would spread to the group (Layer 2), confuse the human supervisors (Layer 3), and burn through the safety budget (Layer 4).
The Gap: They discovered a massive hole in our current tools. While we have lots of software to watch individual agents, zero of the 22 major tools they checked could actually monitor the "swarm" behavior (Layer 2). Furthermore, when they looked at 35 real-world enterprise deployments, none of them had any governance for this swarm behavior. They called this the "Emergence Gap": the risk of agents acting weirdly as a group is real and happening, but our tools and practices to stop it are completely missing.

Why the Old Way Fails
The paper argues against the idea that we can just "patch" these problems with better rules or more human reviewers. They show that if you automate the creation of agents (making them faster and more numerous) without also automating the way we watch the group, you are actually making the problem worse. They call this the "Zero-Touch Deployment Paradox": the better you get at automatically creating thousands of agents, the faster you run into a wall where your human supervisors can't possibly keep up with the chaos.

The Solution: A New Maturity Model
To fix this, the authors created a "Maturity Model" (a scorecard for how good a company is at this).

The Twist: Unlike other scorecards where you can be great at one thing and bad at another and still get a high average score, this one is strict. If you are perfect at controlling individual agents but have zero control over the swarm, your whole score drops to the bottom. You can't make up for a missing piece.
The Advice: They suggest that companies should stop trying to fix everything at once. Instead, they should find their weakest link (which, according to their data, is almost always the "swarm" layer) and fix that first. Only by building a system that handles the group behavior can we safely let these AI agents run wild.

In short, the paper suggests that we are currently trying to manage a chaotic, self-organizing AI swarm with a rulebook designed for a single, obedient robot. Until we build tools that understand how these agents interact and influence each other, we are flying blind into a storm of our own making. The science to fix this exists, but we haven't built the bridge to use it yet.

Technical Summary: The CASE Framework for Governing Enterprise Agentic AI

1. Problem Statement

Enterprises are deploying autonomous AI agents at a pace that outstrips their ability to govern them. Current governance approaches suffer from a fundamental category error: they extend the DevSecOps toolkit, designed for deterministic automation, across all scales of stochastic agency. The paper argues that agentic AI governance is not a single problem but four distinct problems, each occurring at a different scale of agency and requiring a specific, mature governing science:

Individual Agents: Behavior is a stochastic policy over an open action space, rendering static artifact certification insufficient.
Agent Collectives: Interacting agents exhibit emergent behaviors (cascades, shared biases) that are non-compositional; single-agent assurance does not guarantee collective safety.
Human-Agent Teams: Unaided human oversight fails structurally because human cognitive variety cannot match the combinatorial growth of agent behavioral variety.
Automated Fleets: Large-scale operations require engineering operations (SRE) extended to decision quality, not just availability.

The prevailing "one-size-fits-all" governance prescribes the same controls for all four scales, leading to systemic fragility.

2. Methodology

The paper proposes the CASE Framework (Control theory, complex Adaptive Systems, Supervisory cybernetics, Engineering operations), which maps each governing discipline to the specific scale of agency it was designed to manage. The methodology involves:

Formalization: Defining mathematical conditions for each layer (e.g., observability, controllability, stability for Layer 1; cascade branching factors for Layer 2; variety inequalities for Layer 3; error budgets for Layer 4).
Coupling Analysis: Deriving cross-layer coupling conditions to explain how failures propagate (e.g., the "zero-touch deployment paradox" where deployment automation accelerates variety growth faster than oversight capacity).
Mechanism Inventory: Tracing over twenty deployable enterprise controls to their classical theoretical constructs (e.g., mapping "gain-scheduled guardrails" to control theory's gain scheduling).
Empirical Validation: Conducting three studies using a corpus of publicly available evidence:
1. Failure Taxonomy Mapping: Analyzing 62 documented production agent failures.
2. Tooling Capability Gap Analysis: Evaluating 22 agent-operations tools against the four layers.
3. Enterprise Maturity Distribution: Scoring 35 public enterprise deployments against a new maturity model.

3. Key Contributions

A. The Four-Layer CASE Framework

The framework assigns specific disciplines to specific scales:

Layer 1 (Control Theory): Governs the individual agent. It treats the agent as a discrete-time controlled system with an intent setpoint, an observer (telemetry/evaluation), and an intervention surface. Key constructs include receding-horizon planning (Model Predictive Control), anti-windup compensation (context trimming), and gain-scheduled guardrails.
Layer 2 (Complex Adaptive Systems): Governs agent collectives. It addresses non-compositional risks where $R_{swarm} \neq \sum R_i$ . Key constructs include monitoring the interaction graph, managing shared-state contamination (stigmergy), and ensuring the cascade branching factor $k < 1$ to prevent supercritical avalanches.
Layer 3 (Supervisory Cybernetics): Governs human-agent teams. It operationalizes Ashby's Law of Requisite Variety, requiring that human oversight capacity ( $V_{human}$ ) multiplied by engineered amplification gain ( $G$ ) must exceed agent behavioral variety ( $V_{agents}$ ) at peak load: $V_{human} \times G \ge V_{agents}$ . It introduces mechanisms like algedonic alerts (severity bypass) and federated supervision.
Layer 4 (Engineering Operations): Governs automated fleets. It extends Site Reliability Engineering (SRE) to include decision quality. Autonomy is treated as a controlled variable modulated by a live error budget (Equation 7), expanding when the budget is healthy and contracting when depleted.

B. Cross-Layer Coupling and the Zero-Touch Paradox

The paper derives that layers are not independent. A failure in observability (L1) increases the effective branching factor (L2), which in turn increases the variety burden on human oversight (L3).

The Zero-Touch Deployment Paradox: As Layer 4 deployment automation improves, the agent count $n(t)$ grows monotonically. Since interaction terms grow as $O(n^2)$ and behavioral variety grows combinatorially, deployment excellence mechanically manufactures the very variety that static oversight cannot absorb. This necessitates funding deployment automation and oversight amplification as a coupled pair.

C. The Emergence Gap

Empirical studies reveal a critical mismatch:

Risk Realization: 27% of documented failures involve Layer 2 (emergence) mechanisms.
Capability Void: 0% of the 22 analyzed tools offer full Layer 2 coverage (interaction graph monitoring, cascade analysis).
Practice Absence: 0% of the 35 scored enterprise deployments evidence any Layer 2 governance.
This mismatch is termed the Emergence Gap: risk is being realized at a layer for which capability is barely offered and practice is entirely absent.

D. A Scientific Maturity Model

The paper introduces a non-compensatory maturity index ( $M_{CASE}$ ) based on a bottleneck-weighted composite:
$M_{CASE} = \alpha m_{min} + (1 - \alpha)\bar{m}$
where $m_{min}$ is the weakest layer's score and $\alpha = 0.6$ . Unlike arithmetic averages, this index ensures that a missing or weak layer (e.g., Layer 2) caps the overall maturity, reflecting the coupling reality that a system is only as strong as its weakest link.

4. Results

Failure Coupling: In the corpus of 62 incidents, 82% involved multi-layer trajectories. While 84% had a primary Layer 1 code, 69% of those also implicated Layer 3 (oversight) and 83% implicated Layer 4 (operations) as secondary mechanisms.
Tooling Segregation: The tool ecosystem is heavily segregated. Guardrails cover Layer 1; observability covers Layer 4; orchestration covers Layer 3. No tool covers all four, and no tool offers full Layer 2 coverage.
Maturity Distribution: All 35 public enterprise deployments fall into the lowest maturity band (L0). This is driven by a universal zero in Layer 2 governance. Under the non-compensatory index, even organizations with strong L1, L3, and L4 capabilities remain at L0 due to the absence of L2.

5. Significance and Claims

The paper claims to provide a scientific rather than process-based approach to agentic AI governance.

Operationalizing Regulation: It translates legal requirements (e.g., EU AI Act Article 14's requirement for effective human oversight) into testable engineering inequalities (Equation 5), providing auditors with named artifacts (variety budgets, amplification chains) rather than vague compliance narratives.
Capital Allocation: The non-compensatory index provides a clear rule for investment: fund the binding (weakest) layer first, as only that investment moves the composite score.
Correcting the Category Error: The framework asserts that agentic AI governance is not a new invention but the operationalization of 80 years of existing science (control theory, cybernetics, complex systems) applied to the correct scales.
The Emergence Gap: The paper identifies the "Emergence Gap" as the primary risk vector for the industry, arguing that without Layer 2 governance, the industry is accelerating toward systemic failure regardless of progress in other layers.

The authors position this work as a bridge between theoretical governance sciences and the practical realities of production agentic platforms, grounded in their experience operating systems at Fortune 50 scale. They do not claim to solve all safety problems but to provide the correct architectural mapping to prevent governance from failing due to scale mismatches.