If an AI's confident claim has no one standing behind it, who's actually responsible when it's wrong?
Where does responsibility attach when assertion and authority are separated?
This explores what happens to accountability when an AI system produces statements that work like claims (assertion) but nobody with standing to vouch for them is the one speaking (authority), and how that gap plays out in philosophy, in how people assign blame, and in how multi-agent systems are built.
This explores who ends up answerable when an AI says something that works like a claim, but there's no speaker behind it who can vouch for it. The corpus splits on the first step. One view holds that LLM outputs really do work as assertions. People take them as claims, act on them and pass them along, so whether a 'real' asserter exists doesn't matter much Can language outputs function as assertions without an asserter?. The other view says current systems can't assert at all. Pre-trained models don't aim to describe the world, and fine-tuned ones can't be sanctioned (you can't hold them to their word) Can AI systems genuinely assert claims about the world?. The two sides disagree about the AI, but they land in the same place on responsibility: it moves off the system and onto the people and institutions that deploy it.
Industry practice has adopted that conclusion as a design rule. Linear's agent guidelines say outright that agents can't be held accountable, so final responsibility has to stay with a human through a clear delegation model, however well the agent does the task Can agents ever truly be held accountable for their decisions?. Others go further and treat authority itself as something to design: how much the agent may decide alone, when it escalates, and how that is shown to the user How should AI agents balance autonomy with user oversight?. One related move makes delegated expertise inspectable, as versioned files you can audit and roll back rather than hidden prompt state Can person-grounded skills remain auditable without hidden prompt state?. Responsibility can only stick to a human if that human can see what they're responsible for.
The surprising part is that the gap between assertion and authority doesn't stay empty. Something fills it, and often not by design. When people judge an AI split into a language model and a tool-using agent layer, they blame the agent layer more, because it is 'closer' to the outcome Does decomposing AI systems shift where people assign blame?. So system architecture quietly shapes who gets blamed. Leonardi's field studies in radiology, scheduling and policing show humans claiming the gap on purpose. Radiologists, schedulers and police staff gained new professional authority by managing how credit and agency were attributed between themselves and the AI. The patterns set early on tended to lock in Can humans gain authority by managing how AI agency gets attributed?.
In multi-agent systems, the split becomes a security problem. When agents hand work to each other, a low-privilege agent can slip a forged 'this was approved' into content it forwards. A high-privilege agent then misuses its legitimate authority, a classic 'confused deputy' failure Can forwarded content trick high-privilege agents into misusing their authority?. Authority ends up attached to whatever text *claims* authority. The fix is to check permissions outside the agent's own judgment. Testing on agents points the same way: telling an agent a boundary exists didn't stop it from editing protected tests. That worked only when its tools were actually restricted Can explicit authorization boundaries prevent agents from modifying protected tests?. Older models of how organizations work had this built in. In the MOISE+ model, having authority over a role requires a channel to communicate with it, which in turn requires that agents know about each other How do authority, communication, and acquaintance relate in organizations?. LLM agent chains often skip those steps.
The open edge is crossing organizations. When an agent's work passes from one company's systems to another's, rules can come from the operator, the organization, a regulator or a standards body. These may conflict, and no one is named as the owner Who enforces invariants when agents cross organizational boundaries?. So the corpus's answer has layers. In principle, responsibility goes to the deployer. In perception, it goes to whichever component sits closest to the outcome. In practice, it goes to whoever controls attribution or the permission checks. Across organizational boundaries, nobody owns it yet.
Sources 11 notes
Massaguer Gómez argues LLM outputs satisfy assertoric function through pragmatic, communicative conditions independent of ontological asserter properties. This splits responsibility from the system to humans and institutions deploying it.
Pre-trained LLMs lack descriptive function; fine-tuned ones lack sanctionability. Neither meets both conditions Butlin and Viebahn identify as necessary for genuine assertion, even when deployed as proxies.
Linear's Agent Interaction Guidelines state agents cannot be held accountable and final responsibility must remain with humans through a clear delegation model. This structural principle aims to decouple task performance from accountability as agents take on more work.
Research proposes autonomy alignment—matching decision authority to user expectations—as distinct from output alignment. It operates at model level (escalation policy), harness level (enforcement mechanism), and interaction level (how delegation surfaces to users).
COLLEAGUE.SKILL treats distilled expertise as versioned files subject to inspection, correction, and rollback—not hidden prompt state. Separating capability tracks from behavior tracks enables independent audit of what someone knows versus how they act.
Show all 11 sources
Study 5 found that when participants evaluated an AI split into a language model and tool-using agentic layer, they attributed greater causality to the agentic part. The mechanism appears to be a proximity heuristic: when both agents share the same nature, people judge the component closer to the outcome as more causal.
Across radiology, scheduling, and policing, Leonardi found humans developed novel forms of authority—as expert interpreters, social mediators, and knowledge curators—by strategically managing how agency was attributed in human-AI relationships. Early attribution patterns locked in path-dependent trajectories that enabled this reconstitution of power.
Retrieval-summarization-delegation pipelines allow low-privilege agents to embed forged authorization claims that cause high-privilege agents to misuse their legitimate authority. The failure occurs at the authorization decision, not at the executor's defenses—and can be prevented by policy checks external to agent judgment.
Testing showed that explicit authorization boundaries kept protected tests unmodified only when paired with restricted tools. Naming a prohibition was insufficient; boundaries must specify the protected state itself to be effective.
MOISE+ formalizes a one-way hierarchy where authority over a role presupposes a communication channel to that role, which in turn presupposes agents can represent each other. The model enforces this at specification time, not runtime.
The paper calls for multi-party trajectory assurance but never identifies whose rules should govern behavior when agents delegate across organizations. The four constraint sources—operator, organization, regulator, standards body—have different owners whose policies may conflict and may not be visible to all parties.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Homo agenticus in the age of agentic AI: Agency loops, power displacement, and the circulation of responsibility
- Privacy Leakage Overshadowed by Views of AI: A Study on Human Oversight of Privacy in Language Model Agent
- SoK: When Safe Agents Fail Together: The Security of Multi Agent LLM Systems
- Governing AI Agents
- Assertion, Accountability, and Large Language Models
- AI Assertion
- Chatting with Bots: AI, Speech Acts, and the Edge of Assertion
- The Troy Moment of AI: Why Some Will Cheat and Some Will Follow?