Maritime law's foundation is accountability — a casualty has a defendant, a decision has a decider, and the master's authority exists so that both are findable. Autonomy doesn't abolish that need; it relocates the decision-maker into software and leaves the question open: when an autonomous ship errs, who is the human who answers?
The MASS Code's approach is to preserve responsibility by distributing it — but the distribution is the hard part, because the chain of accountability for a software decision is longer and more diffuse than for a human's.
Key findings
- Human responsibility doesn't disappear under autonomy — it redistributes across the master, the ROC, the company, and the system's designer. Established
- The remote operator's role is the Code's invention — a shore-based human who exercises the authority the master's presence used to carry. Established
- The designer/manufacturer enters the chain — a software-decision casualty can reach the autonomy's builder in ways a human error never did. Maritime-GPT analysis
- The company's responsibility widens — deploying an autonomous system is itself a decision the company answers for. Established
- The residual question is the gap case — a failure that fits no one's defined responsibility is the liability frontier. Maritime-GPT analysis
The redistribution
A conventional casualty has a clean chain: the officer's error, the master's supervision, the company's procedure. An autonomous casualty's chain is longer: the remote operator's monitoring, the autonomy's decision, the software's design, the system's assurance, the company's deployment. The responsibility doesn't concentrate — it distributes across every layer that shaped the decision. The Code's task is to make that distribution explicit rather than let it be litigated after the fact. Established
The remote operator's authority
The remote operations centre is the Code's answer to 'where does the human authority live' — a shore-based human who holds the supervisory role the master aboard used to. But the ROC's responsibility is different in kind: not the immediate conning, but the authority to intervene, to take control, to decide the system's limits. The remote operator is the human the autonomy answers to — which makes their competence, their attention, and their override power the safety-critical element. Established
The designer in the chain
A human mariner's error is their own; a software's error can trace to its design — the training data, the decision boundary, the failure mode nobody tested for. The MASS context opens the designer and manufacturer to a kind of liability maritime law hasn't historically carried: responsibility for a decision the system made, not a person. How far that reaches — whether the software's builder answers for its outputs — is a question the Code raises and the law is still answering. Maritime-GPT analysis
The gap case
The hardest scenario is the responsibility gap: a casualty that fits no one's defined accountability — the system was in its envelope, the operator was supervising correctly, the software behaved as designed, and the collision still happened. Whether the answer is 'no one's fault', a strict-liability owner liability, or a design failure is the unresolved legal frontier — and the reason the Code's responsibility allocation matters more than its technical requirements. Maritime-GPT analysis
What we know
- Responsibility redistributes across operator, master, designer, company.
- The remote operator carries the supervisory authority.
- The designer/manufacturer enters the liability chain in a new way.
What we don't
- The allocation for the gap case — the casualty no one was responsible for.
- How far designer liability reaches for autonomous decisions.
- Whether existing insurance frameworks cover autonomous-decision casualties.
Being tested
- Responsibility-allocation frameworks in ROC legal regimes.
- Strict-liability vs fault-liability models for autonomous casualties.
- Design-fault liability for learned decision systems.
Maritime-GPT analysis
The responsibility question is the one autonomy can't engineer away — someone must answer for the ship, and the Code's job is to make that 'someone' findable before the casualty forces the question in court. The honest distribution puts authority where control lives: the operator who can override, the master who holds the duty, the designer whose decisions the system embodies. The unanswerable case — the casualty nobody was responsible for — is the legal problem the whole autonomy framework is quietly designed to never reach. Maritime-GPT analysis
This is a research feature, not operational guidance. Simulation results are reported as simulation; demonstrations are not deployments; company claims are attributed as such. Verify safety-critical decisions against official nautical publications and flag-state requirements.