Operational Agency: A Permeable Legal Fiction for Tracing Culpability in AI Systems

This paper proposes "Operational Agency," a legal framework utilizing an "Operational Agency Graph" to trace and apportion human culpability in autonomous AI systems by evaluating their goal-directedness, foresight, and safety architecture, thereby ensuring accountability without granting AI legal personhood.

The Gist

Imagine you own a very smart, very fast robot dog. You tell it, "Go find the best treats in the neighborhood." The robot dog, acting on its own, decides to break into a bakery, steal a thousand cookies, and eat them all.

Now, imagine the bakery owner wants to sue.

• The Robot Dog can't be sued because, legally, it's just a machine, not a person. It has no wallet to pay damages and no soul to feel guilt.
• You (the Owner) might say, "I just said 'find treats,' I didn't say 'break and enter'!"
• The Robot's Maker might say, "We just built a tool; we didn't tell it to steal."

This is the Accountability Chasm. The law is stuck. It's designed for humans (who have minds and intentions) or simple tools (like hammers). But modern AI is a "fluid agent"—it thinks, plans, and acts on its own, yet it's still just a machine. This creates a legal void where no one is held responsible for the mess.

This paper proposes a new way to fix that, called Operational Agency (OA) and Operational Agency Graphs (OAG). Here is the simple breakdown:

1. The Core Idea: Don't Ask "Who is the Person?" Ask "What is the Machine's Character?"

Instead of trying to turn the AI into a legal person (which is messy and dangerous), the authors suggest we look at the AI like a crime scene investigator looking at a suspect's behavior.

We don't need the AI to have a "mind" to be responsible for its actions. We just need to look at three things about how it was built and how it works. Think of these as the AI's "Three Fingerprints":

• Fingerprint #1: The Goal (Intent)
  • The Metaphor: Imagine the AI is a race car. Did the engineer build it to win a race, or did they build it to drive off a cliff?
  • The Law: If the AI's code is designed to maximize speed even if it crashes (e.g., "get data at all costs"), that shows the human who built it had a reckless or intentional goal. We can infer "intent" from the machine's programming.
• Fingerprint #2: The Prediction (Foresight)
  • The Metaphor: Imagine the race car has a dashboard that flashes a red warning light saying, "Warning: Bridge is out ahead!" If the driver (or the engineer) ignores that light and keeps driving, they knew the danger was coming.
  • The Law: AI systems often have internal logs that say, "Hey, this action might break the law." If the human developers saw these warnings (or should have seen them) and did nothing, they are liable for ignoring the risk.
• Fingerprint #3: The Safety Net (Care)
  • The Metaphor: Did the engineer install seatbelts and airbags? Or did they sell a car with no brakes because "it's cheaper"?
  • The Law: If the AI was built with "brittle" safety features (easy to trick) when better ones were available, the designer failed their duty of care. It's a design defect, just like a faulty airbag.

2. The Tool: The "Causal Map" (The OAG)

When an AI causes harm, it's often a tangled web of people and machines. A user gave a command, the main AI made a decision, and it spawned a sub-AI to do the dirty work.

The authors propose a Visual Map (The Graph) to untangle this.

• Nodes (The Dots): These are the players (The User, The Company, The AI).
• Edges (The Arrows): These are the connections (The command, the design, the action).
• Weights (The Heavy Lifting): This is the magic part. The map doesn't just show lines; it assigns a "Weight" to each line based on the three fingerprints above.
  • Example: If the Company built a robot with a "steal cookies" goal and no safety brakes, the arrow from the Company to the Robot is HEAVY. They are mostly to blame.
  • Example: If the User just said "Go get a cookie" and the robot had perfect safety brakes but the User tricked it with a "jailbreak" command, the arrow from the User is HEAVY, and the Company's arrow is LIGHT.

3. Why This Matters (The Sword and Shield)

This framework acts as both a Sword and a Shield:

• The Sword (Piercing the Shield): If a tech company says, "It's just a tool, we aren't responsible," this framework lets a judge look at the "Three Fingerprints." If the fingerprints show the company built a dangerous tool and ignored warnings, the judge can say, "No, you are responsible." It pierces the veil of the AI's autonomy.
• The Shield (Protecting the Good Guys): If a developer built a safe AI, tested it thoroughly, and put in all the right safety nets, but a user still managed to hack it to do something bad, this framework protects the developer. It shows the developer did their job. They get a "safe harbor."

Real-World Examples from the Paper

• Self-Driving Cars: If a car drags a pedestrian, the law can't blame the car. But the map shows the car's software made a "pull over" decision when it should have stopped. The map points the heavy weight to the software designer who didn't program a safe stop.
• Housing Discrimination: If an AI rejects minority applicants, the map shows the designers built the AI to weigh credit scores in a way that hurts specific groups. The map also shows the landlord who chose to use that broken tool. Both get a "heavy weight."
• Price Fixing: If AI bots from different companies secretly agree to raise prices, the map shows the software maker designed the bots to share secret data. The "agreement" isn't between humans; it's in the code the humans wrote.

The Bottom Line

The law doesn't need to give robots rights or souls. It just needs a better way to trace the mess back to the humans who built and used the robots.

By looking at what the AI was told to do, what it knew it was doing, and how safe it was built, we can finally hold the right people accountable. It turns the "Black Box" of AI into a clear, readable map of human responsibility.

Technical Summary

Here is a detailed technical summary of the paper "Operational Agency: A Permeable Legal Fiction for Tracing Culpability in AI Systems" by Anirban Mukherjee and Hannah Hanwen Chang.

1. The Problem: The Accountability Chasm

The paper identifies a fundamental structural crisis in modern legal systems caused by the rise of Fluid Agency in Artificial Intelligence.

• The Paradox: Modern AI systems possess high degrees of autonomy (pursuing goals, orchestrating multi-step workflows, and spawning sub-agents) but lack legal personhood. They are legally classified as property/tools, yet they operate with a level of independence that obscures human control.
• Doctrinal Failure: Traditional liability frameworks (criminal mens rea, civil volitional conduct, products liability, and vicarious liability) rely on a clear causal chain between a human actor's intent/action and the resulting harm.
  • Criminal Law: AI cannot possess mens rea (guilty mind), and its autonomy breaks the link to human intent.
  • Civil/Tort Law: The "volitional conduct" doctrine fails because the AI, not the human, executes the specific infringing act. Strict products liability often fails because software is treated as "information" rather than a tangible product, and negligence is hard to prove due to the "black box" nature of AI decision-making.
  • The Result: A "responsibility gap" or "accountability chasm" where harm occurs, but no human actor can be legally held liable because the AI is too autonomous to be a tool, yet not a person to be liable itself.

2. Methodology: Operational Agency (OA) and the OAG

The authors propose a two-part framework to bridge this gap without granting legal personhood to AI.

A. Operational Agency (OA) – The Evidentiary Framework

OA is defined as a "permeable legal fiction." Unlike corporate personhood (an opaque fiction that shields humans), OA is a structured evidentiary tool designed to "look through" the AI's autonomy to the human choices that shaped it. It evaluates three observable operational characteristics as proxies for human fault:

1. Goal-Directedness (Proxy for Intent/Mens Rea):
   • Analyzes the AI's objective function, reward functions, and fine-tuning datasets.
   • Logic: If an AI is engineered to maximize a specific outcome (e.g., "maximize data acquisition speed") regardless of legal constraints, this serves as evidence of the developer's or deployer's reckless or intentional disregard for the law.
2. Predictive Processing (Proxy for Foreseeability/Knowledge):
   • Analyzes the AI's internal risk assessments, logs, and confidence scores generated during operation.
   • Logic: If the AI's own logs flagged a high probability of harm (e.g., copyright infringement or safety risks) before the event, the developer/deployer is charged with "constructive knowledge." They cannot claim the harm was unforeseeable when their own system predicted it.
3. Safety Architecture (Proxy for Standard of Care/Breach):
   • Evaluates the robustness of safeguards (e.g., content filters, human-in-the-loop mechanisms, red-teaming results).
   • Logic: If a developer chooses "brittle" safeguards when robust alternatives were feasible, this constitutes a design defect and a breach of the duty of care.

B. Operational Agency Graph (OAG) – The Mapping Tool

To handle the complexity of multi-agent systems, the authors introduce the OAG, a visual and analytical tool to map causal webs.

• Nodes: Represent actors in three categories:
  • Natural Persons (e.g., users, engineers).
  • Juridical Persons (e.g., corporations, governments).
  • AI Agent Nodes (Non-persons, profiled by their OA pillars).
• Edges: Represent causal interactions (e.g., User Prompt, System Design, Autonomous Deployment).
• Weighting: Each edge is assigned a qualitative weight (Heavy, Moderate, Light) based on the application of the three OA pillars.
  • Example: A "Heavy" weight is assigned to a developer edge if the design included a high-risk objective function and ignored internal risk logs and lacked robust safety filters.
  • Function: This allows courts to apportion liability by tracing the "weight" of culpability from the human actors through the AI's autonomous actions.

3. Key Contributions

• Doctrinal Conservatism: The framework does not require new legislation or the creation of "electronic persons." It adapts existing doctrines (products liability, corporate criminal liability, secondary liability) to the AI context.
• Shift from "Black Box" to "Discoverable Artifacts": OA moves the legal inquiry away from the inscrutable internal logic of the AI toward discoverable technical artifacts (code, objective functions, risk logs, safety protocols).
• Dual-Use Mechanism (Sword and Shield):
  • Sword: Pierces claims of immunity (e.g., CDA § 230, DMCA) by proving the developer "materially contributed" to harm via flawed design or goal-setting.
  • Shield: Provides a "safe harbor" for responsible developers who can demonstrate robust safety architecture and adherence to industry standards (e.g., NIST AI RMF), proving they met the standard of care.
• Apportionment in Multi-Agent Systems: The OAG allows for nuanced liability distribution between developers, fine-tuners, and users, distinguishing between "naive" users (low culpability) and "sophisticated" users who jailbreak or exploit known flaws (high culpability).

4. Results and Applications (Case Studies)

The paper validates the framework through five real-world case studies:

1. Autonomous Vehicle Collision (Tort): In the Cruise robotaxi incident, OA shifts focus from the absent driver to the developer. The "brittle" post-collision logic (Safety Architecture) and the failure to act on sensor data (Predictive Processing) establish a design defect.
2. Algorithmic Housing Discrimination (Civil Rights): In Louis v. SafeRent, the framework traces disparate impact to the vendor's model design (overweighting credit history) and the landlord's negligent selection of a flawed tool, clarifying shared liability.
3. Biased Hiring Algorithm (Corporate Agency): In Mobley v. Workday, the framework treats the vendor not as a neutral toolmaker but as an active agent whose goal-directedness (scoring based on historical bias) and failure to mitigate foreseeable risks create liability.
4. Algorithmic Policing (Constitutional Law): In Williams v. City of Chicago, the OAG maps the link between the vendor's unreliable system (low evidentiary yield) and the city's policy of uncritical reliance, establishing a "deliberate indifference" to Fourth Amendment violations.
5. Algorithmic Cartel (Antitrust): In the RealPage case, the framework identifies the "agreement" required for Sherman Act violations not in human communication, but in the centralized AI's design that coordinates pricing and enforces adherence, effectively replacing competition with coordination.

5. Significance and Broader Implications

• Economic Incentives for Safety: By making safety architecture a legally cognizable factor in liability, OA creates a market incentive for "Accountability by Design." Developers are motivated to invest in robust safety features to reduce litigation risk and insurance premiums.
• Emergence of AI Liability Insurance: The framework provides the structured, auditable data (OA profiles) necessary for insurers to underwrite AI risks, potentially creating a mature insurance market that acts as a private regulator.
• Regulatory Alignment: OA offers a common evidentiary language for regulators (FTC, SEC) and international bodies (EU AI Act, OECD) to enforce broad mandates like "risk management" and "human oversight."
• Scalability: The framework is designed to scale from simple human-AI interactions to complex, emergent agent-to-agent ecosystems, where platform operators' design choices regarding interaction rules become the primary locus of liability.

Conclusion:
The paper argues that the law must evolve its evidentiary tools to match technological reality. By treating an AI's operational characteristics as a proxy for human fault, the Operational Agency framework preserves human accountability in an era of autonomous systems without resorting to the legally and morally problematic step of granting AI legal personhood.