This document defines how responsibility is created, transferred, and terminated within executable language systems.

It treats delegation not as a convenience mechanism, but as a formally constrained operation that determines who is accountable for execution outcomes, side effects, and failure states.

Responsibility as an execution primitive

Responsibility is treated here as a first-class execution concept.

It is not inferred from intent, nor implied by output generation. Responsibility exists only where execution authority has been explicitly granted and bounded by defined conditions.

Without a formal responsibility model, execution cannot be meaningfully governed.

Delegation is a grant, not a handoff

Delegation is defined as the granting of execution authority within a specified semantic scope.

A delegation does not eliminate the delegator’s responsibility by default. It creates a new responsibility relationship whose properties must be explicitly declared.

Delegation therefore introduces structure, not abdication.

Three properties of responsibility

This work models responsibility through three orthogonal properties:

1. Grantability

Responsibility can only be granted by an entity that legitimately holds execution authority over the delegated scope.

Grantability requires:

Responsibility cannot be implicitly assumed or inferred.

2. Transferability

Responsibility may be transferable, partially transferable, or non-transferable.

Transferability must be explicitly stated. Absent such declaration, responsibility remains shared or retained.

Transferability determines whether:

3. Terminability

Responsibility must have explicit termination conditions.

Termination may occur when:

Without terminability, responsibility becomes indefinite and ungovernable.

Delegation without responsibility is invalid

Systems that allow agents to act without explicit responsibility assignment create execution without accountability.

This work treats such systems as architecturally unsound.

Execution authority without responsibility is indistinguishable from uncontrolled side effects.

Responsibility and completion semantics

Responsibility is evaluated relative to completion conditions.

An agent is responsible for execution only until completion semantics associated with its scope are satisfied or responsibility is explicitly terminated.

Failure to reach completion does not automatically terminate responsibility.

This distinction enables:

Responsibility chains in multi-agent systems

In multi-agent environments, delegation creates responsibility chains rather than isolated assignments.

Each link in the chain must be:

Responsibility chains enable attribution without requiring centralized control.

Institutional implications

Formal delegation and responsibility models are prerequisites for integrating AI systems into:

Without such models, AI-mediated actions cannot be meaningfully audited or insured.

Relation to execution and governance layers

This model operates alongside:

It does not prescribe organizational policy. It defines the minimal structural conditions under which policy can be enforced.

Reading note

This model should be read as a foundational constraint for any system that claims to support:

It is not optional. It is the boundary between automation and abdication.