Distinguishing Action and State Responsibility in Agent Delegation

19 concepts3 papers1 proposal

When we delegate a task in the real world, we rarely just hand over a rigid sequence of instructions. If a manager asks an employee to ensure a client presentation is ready by tomorrow morning, the manager does not necessarily care whether the employee designs the slides personally, collaborates with a teammate, or hires a graphic designer. What matters is that the state of affairs—a completed presentation—is achieved, and that the employee remains accountable for ensuring that outcome.

In early multi-agent systems, however, delegation was almost exclusively modeled as action execution. An agent would request another agent to execute a specific plan or procedure. If the execution failed or the environment changed, the chain of accountability quickly broke down.

To solve this, a series of foundational papers established a formal framework for delegation semantics. By separating the performance of an action from the responsibility for an outcome, this research direction enables agents to autonomously navigate complex, nested organizational structures while strictly maintaining chains of accountability.

The Core Distinction: Action vs. State Delegation

The bedrock of this framework is the formal separation between two types of delegation. As articulated in A Model of Delegation for Multi-agent Systems, delegation must distinguish between:

  1. Action-Based (or Event-Based) Delegation: Entrusting an agent to perform a specific action or procedure.
  2. State-Based Delegation: Entrusting an agent to bring about or maintain a specific state of affairs.

In Delegation and Responsibility, Chris Reed 0001 et al. point out that traditional models conflate actively performing a task with ensuring that a task is completed. When an agent accepts a state-based delegation, they accept responsibility for the outcome, which grants them the autonomy to decide how to achieve it.

[Action Delegation] ---> Agent performs specific procedure ---> Rigid execution
[State Delegation]  ---> Agent ensures state of affairs    ---> Flexible execution & sub-delegation

This distinction is crucial for robust multi-agent interactions. If an agent is delegated an action, its responsibility ends the moment the action is executed, regardless of whether the overarching goal was met. If the agent is delegated a state, it remains on the hook. It can choose to execute actions itself, or it can further delegate those actions to other sub-agents.

Tracking Responsibility Through Nested Chains

When tasks are passed down through multiple layers of agents, tracking who is ultimately accountable becomes a significant challenge. If Agent A delegates a task to Agent B, and Agent B sub-delegates it to Agent C, who is to blame if Agent C fails?

To resolve this, Chris Reed 0001 et al. introduced a logic of agentative action in A Model of Delegation for Multi-agent Systems. They proposed specific axioms to govern the transfer of responsibility for both states (using formalisms like QS and TSS) and actions (QT and TST). These axioms mathematically define how responsibility shifts during delegation:

  • Responsibility is not lost through sub-delegation: When Agent B delegates the underlying actions to Agent C, Agent B still retains state-based responsibility toward Agent A.
  • Whole-hearted satisfaction: In Delegation and Responsibility, the authors introduce this concept to describe an agent's active commitment to an imperative. It means the agent cannot simply hope the state occurs by chance; they must actively monitor and ensure its completion.

This formal structure also allows for explicit delegation restrictions. For example, a high-level agent can specify that a task must be handled personally, explicitly prohibiting further sub-delegation.

Operationalizing Responsibility in Agent Architectures

To prove that this distinction is more than just philosophical, Martin J. Kollingbaum et al. brought these concepts into practical software engineering by implementing them within the NoA agent architecture in Implementing responsibility for states and events.

In a typical BDI (Belief-Desire-Intention) agent, plans are triggered by specific events or goals. The NoA architecture extends this by allowing agents to explicitly hold and reason about "state responsibilities" and "event responsibilities."

[State Responsibility Active] 
             │
             ▼
    Is state maintained? ───(Yes)───> [Do Nothing]
             │
           (No)
             │
             ▼
   Trigger Event-Based Plans ───> [Execute Actions / Sub-delegate]

Why does this architecture work so well in dynamic environments? If an agent has a state responsibility (e.g., keeping a warehouse temperature stable), it does not just run a single script. If an unexpected environmental event disrupts the temperature, the agent's internal reasoning engine recognizes that its state responsibility is violated. This automatically triggers new event-based responsibilities (actions) to fix the issue, or prompts the agent to delegate the repair to a specialized maintenance agent.

By decoupling the high-level contract (the state) from the low-level execution (the events), the authors demonstrated that multi-agent systems can mirror real-world organizational delegation, achieving both high autonomy and strict accountability.

Key Foundational Work

A Model of Delegation for Multi-agent Systems (2002) — contributed 6 concept elements to this direction.
Delegation and Responsibility (2000) — contributed 5 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_delegation_semantics_bc4e2b3b,
  title = {delegation semantics},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/delegation-semantics/rdr_bc4e2b3b721442fbafbf77fdd3329e90},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_delegation_semantics_bc4e2b3b_v1,
  title = {delegation semantics},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/delegation-semantics/rdr_bc4e2b3b721442fbafbf77fdd3329e90/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake