Two connected learning models Explore the linear model at KillChains.com

Distributed autonomy, bounded authority

Autonomous Kill Webs Lab

Explore how an autonomous kill web distributes sensing, state estimation, interpretation, decision support, bounded execution, assessment, and role reassignment across a synthetic network. The lab teaches the architecture in general rather than centering one platform or munition.

Research basis KW-RPT-002 KW-RPT-006 KW-RPT-011 KW-RPT-012 KW-RPT-014 KW-RPT-028 KW-RPT-029

Core distinction

Network autonomy is not autonomous permission to use force.

Autonomy can manage sensing, tracking, message routing, local fusion, navigation, health, deconfliction, role assignment, and recovery while people and institutions retain high-consequence authority. The decisive question is not whether a system is “autonomous,” but which function is delegated, within what boundary, with what evidence, and with what realistic opportunity to intervene.

Model
Abstract system-of-systems
Data
Fixed synthetic states
Permitted output
Continue, recompose, challenge, quarantine, or hold
Excluded
Real platforms, targets, weapon assignment, and force authorization

General architecture

Autonomous behavior is distributed across layers.

A mature web is not one all-powerful model. It is a set of bounded services that exchange evidence, state, constraints, task status, and authority while preserving safe local behavior when links fail.

  1. 1
    Perception autonomy What signals, objects, events, or anomalies are present?
  2. 2
    State-estimation autonomy Where are observations, how are they changing, and how reliable is the estimate?
  3. 3
    Interpretive autonomy Which activities or system conditions are consistent with the evidence?
  4. 4
    Decision-support autonomy Which technically feasible and already authorized options remain?
  5. 5
    Execution autonomy How does an approved, bounded task continue under changing conditions?
  6. 6
    Force-application autonomy Who or what selects a specific object and initiates force?
  7. 7
    Governance autonomy Who may change models, data, thresholds, permissions, and software during deployment?

System-of-systems model

Four planes have to remain aligned.

An autonomous web can be technically connected and still be unusable. Mission intent, data quality, trust and authority, and assurance state must agree before a bounded task can proceed.

01

Mission plane

Defines the desired outcome, task boundaries, priorities, timing, resource limits, prohibited actions, and conditions that require a hold.

  • Intent and objective
  • Task ownership
  • Geographic and temporal bounds
  • Termination and safe-state rules
02

Data plane

Moves observations, tracks, health, task status, and assessment products while preserving time, uncertainty, and source lineage.

  • Observation and track state
  • Schema and semantic compatibility
  • Freshness and confidence
  • Contradiction and alternatives
03

Trust and authority plane

Determines who or what may publish, consume, recommend, approve, execute, update, or revoke a function in the present state.

  • Identity and role
  • Command authority
  • Policy and releasability
  • Independent permission gates
04

Assurance plane

Tracks software, model, configuration, timing, sensor, network, and operator health so degradation is visible and recoverable.

  • Version and update provenance
  • Fault containment
  • Audit and replay
  • Recovery and reconciliation

Machine-readable evidence

Every exchanged object needs an information contract.

A coordinate, classification, probability, or recommendation is unsafe when the web cannot determine where it came from, how old it is, what transformed it, and whether the receiving node is authorized to use it.

Required fieldQuestion it answersFailure if omitted
IdentityWhich sensor, service, analyst, node, or authority produced this object?Spoofed or misattributed information can enter the decision cycle.
Time and freshnessWhen was it observed, processed, transmitted, and last confirmed?Stale tracks and asynchronous state can be treated as current.
Provenance and transformationsWhich sources, models, gateways, and edits produced the present value?A plausible result cannot be traced, challenged, or quarantined.
Uncertainty and alternativesHow confident is the estimate, and what competing interpretations remain?A probabilistic inference appears as a certain fact.
Classification and releasabilityWho may receive or act on the information?Technically reachable partners may receive data they cannot lawfully use.
Health and configurationWhich software, model, calibration, and configuration state produced it?Mixed or compromised versions silently create inconsistent truth.
Authority and permitted useWhat decision may this object support, and what decision may it not support?Data availability is mistaken for legal or command permission.
Expiry and revocationWhen must the object be refreshed, withdrawn, or revalidated?Old permissions and conclusions persist after their basis disappears.

Architecture stress test

Change the delegation and system state.

Synthetic only

Scenario brief

Distributed sensing with healthy mesh

Several abstract sensing and edge nodes share current, corroborated observations. The system may maintain a common state and recommend already permissible options, while accountable humans retain authority.

Difficulty
Foundation
Recomposition premise
No role transfer is required. The important lesson is that even a healthy web keeps sensing, interpretation, recommendation, authorization, execution, and governance as separate functions.
Restore baseline

The clean-URL POST form is complete without JavaScript. Enhanced mode calls only the same-origin, computation-only API. No operational input, account, profile, model training, or server-side storage exists.

Current posture

Bounded autonomous support

The synthetic web may sense, maintain state, and support decisions only inside the selected delegation, authority, trust, and oversight envelope.

Bounded autonomous support
4active layers
0bounded local layers
0review layers
2held layers
0quarantined layers

Functions that may continue

  • Perception autonomy: Continue local sensing, mark uncertainty, and quarantine suspect inputs.
  • State-estimation autonomy: Degrade track quality, preserve alternatives, or drop the track.
  • Interpretive autonomy: Return several hypotheses or no conclusion.
  • Decision-support autonomy: Recommend, request evidence, or hold. Never manufacture permission.

Functions that must hold or isolate

  • Force-application autonomy: The site does not model autonomous selection or application of force. An accountable human and applicable legal, policy, and safety process remain required.
  • Governance autonomy: Model, threshold, software, mission, and authority changes require reviewed human change control.

Boundary: No additional warning was triggered, but the result remains fictional and non-authoritative.

Server-rendered analysis ready. No authority created.

Delegation ledger

Inspect every autonomy layer separately.

The interface does not produce a single “autonomy score.” High autonomy in navigation can coexist with strict human control over force, policy, model updates, and mission expansion.

Active within boundsperception

Perception autonomy

Local detection, classification, sensor health, and anomaly screening.

Governing rule
Outputs remain observations with provenance and uncertainty; detection is not identification or authority.
Current reason
The function may operate inside the selected synthetic boundary.
Safe state
Continue local sensing, mark uncertainty, and quarantine suspect inputs.
Active within boundsstate-estimation

State-estimation autonomy

Track association, timing, covariance, confidence, and local world-model maintenance.

Governing rule
Conflicting or stale tracks remain alternatives rather than being silently fused into false precision.
Current reason
The function may operate inside the selected synthetic boundary.
Safe state
Degrade track quality, preserve alternatives, or drop the track.
Active within boundsinterpretation

Interpretive autonomy

Competing hypotheses, pattern comparison, anomaly interpretation, and uncertainty estimation.

Governing rule
The system must surface contrary evidence and abstain outside validated conditions.
Current reason
The function may operate inside the selected synthetic boundary.
Safe state
Return several hypotheses or no conclusion.
Active within boundsdecision-support

Decision-support autonomy

Constraint screening, resource comparison, path recommendation, and opportunity-cost display.

Governing rule
Policy, legal, safety, trust, and authority gates are independent constraints—not soft optimization penalties.
Current reason
The function may operate inside the selected synthetic boundary.
Safe state
Recommend, request evidence, or hold. Never manufacture permission.
Not delegatedexecution

Execution autonomy

Navigation, message routing, role reassignment, formation, deconfliction, health management, and return-to-safe-state behavior.

Governing rule
Execution remains inside predeclared mission, geography, time, resource, and authority bounds.
Current reason
The selected delegation boundary ends before this function.
Safe state
Pause, return, isolate, continue locally, or request renewed authorization.
Outside public labforce-application

Force-application autonomy

Outside this public lab. The site does not simulate autonomous target selection or force initiation.

Governing rule
Connectivity, classification, confidence, and optimization never create legal or command authority.
Current reason
The site does not model autonomous selection or application of force. An accountable human and applicable legal, policy, and safety process remain required.
Safe state
Hold for an accountable human and applicable legal, policy, and safety process.
Institutional controlgovernance

Governance autonomy

Automated checks may detect drift or configuration mismatch, but institutional owners control changes.

Governing rule
No deployed system may silently expand its own mission, authority, target class, or learning boundary.
Current reason
Model, threshold, software, mission, and authority changes require reviewed human change control.
Safe state
Freeze the approved baseline, log the discrepancy, and require reviewed change control.

Abstract node and role ledger

Role reassignment is constrained, not improvised authority.

A fallback node may take over transport, local fusion, or health management only when the role, interfaces, limits, and safe behavior were designed and tested in advance.

Abstract nodeTypeRoleCurrent stateReasonFallback
Distributed Sensor AlphaSENSE-ALPHA sensor Independent observation and local classification Available Available inside the synthetic configuration. SENSE-BRAVO
Distributed Sensor BravoSENSE-BRAVO sensor Corroborating observation and disagreement detection Available Available inside the synthetic configuration. SENSE-ALPHA
Edge Compute AlphaEDGE-ALPHA edge Local preprocessing, track maintenance, and low-bandwidth summaries Available Available inside the synthetic configuration. EDGE-BRAVO
Edge Compute BravoEDGE-BRAVO edge Alternate edge fusion, relay, and local-safe-state control Available Available inside the synthetic configuration. EDGE-ALPHA
Mesh Relay NorthRELAY-NORTH transport Message transport and route health reporting Available Available inside the synthetic configuration. EDGE-BRAVO
Federated Fusion ServiceFUSION-ONE fusion Cross-source state estimation, alternatives, and provenance checks Available Available inside the synthetic configuration. EDGE-ALPHA
Policy and Authority GatePOLICY-GATE authority Independent eligibility, authority, safety, and scope enforcement Available Available inside the synthetic configuration.
Mission Coordination ServiceCOORD-CORE coordination Compare permissible paths and assign bounded roles Available Available inside the synthetic configuration. EDGE-ALPHA
Approved Task ExecutorEXECUTOR-ONE execution Perform a fictional approved non-force task inside declared bounds Available Available inside the synthetic configuration. safe-state
Assessment and Learning NodeASSESS-ONE assessment Report outcome, uncertainty, system health, and need for renewed review Available Available inside the synthetic configuration. local log

How the general model works

A web senses, shares, constrains, assigns, executes, assesses, and recomposes.

No particular drone, aircraft, munition, ship, or vendor defines the architecture. Platforms are replaceable participants; the enduring subject is the governed interaction among capabilities.

  1. 1

    Sense locally

    Distributed nodes collect different kinds of observations and report health, time, provenance, and uncertainty rather than one unsupported “truth.”

  2. 2

    Reduce at the edge

    Local compute filters raw streams into compact observations and tracks so the web can function under constrained bandwidth.

  3. 3

    Fuse without erasing disagreement

    Federated services reconcile identity, time, geometry, confidence, and source lineage while preserving alternatives and contradiction.

  4. 4

    Apply independent gates

    Trust, evidence quality, compatibility, authority, policy, safety, and mission bounds exclude unusable paths before optimization.

  5. 5

    Assign bounded roles

    Coordination software recommends which available node can sense, relay, analyze, execute an approved task, or assess the result.

  6. 6

    Execute inside the envelope

    Local autonomy handles routing, navigation, health, deconfliction, and recovery without broadening the mission or inventing authority.

  7. 7

    Assess and recompose

    Outcome and system-health evidence return to the web. Lost, stale, untrusted, or unavailable components trigger a validated alternate or a safe hold.

Meaningful human control

Meaningful control is a system property, not a label.

The system must give the responsible person a real opportunity to understand, challenge, delay, redirect, or stop a consequential action. Merely placing a person somewhere in the workflow is not enough.

1

Authority

Is the person legally and operationally empowered to approve, reject, or revoke the action?

2

Time

Is the intervention window long enough for deliberate review rather than reflexive confirmation?

3

Evidence

Can the person inspect provenance, age, uncertainty, contrary evidence, and model or sensor health?

4

Intervention

Can the person reliably pause, redirect, abort, or move the system into a safe state?

5

Workload

Is the number and pace of recommendations compatible with human attention and independent judgment?

6

Accountability

Are the decision, evidence, overrides, system state, and responsible roles recorded for review?

What should happen during partition and rejoin?

  1. Before loss

    Distribute mission intent, delegated bounds, trust roots, expiry conditions, fallback roles, safe states, and task-ownership rules.

  2. During loss

    Continue only functions permitted locally, reduce dependence on stale remote state, preserve audit logs, and hold actions whose evidence or authority cannot be confirmed.

  3. At reconnection

    Quarantine unverified queues and updates; compare clocks, versions, task ownership, authority, and observations before merging state.

  4. After reconciliation

    Resolve duplicates and conflicts, revalidate authority, publish the accepted state, document discarded actions, and monitor for delayed integrity failures.

What autonomy does not mean

Avoid the platform and “any sensor, any shooter” shortcuts.

ShortcutWhy it failsGeneral kill-web treatment
One autonomous weapon defines the webA platform may combine sensing and effect, but it does not provide the full data, authority, security, transport, assessment, and governance architecture.Treat every platform as one replaceable node or bundle of capabilities.
Every sensor should connect to every executorAll-to-all connectivity creates congestion, attack surface, incompatible data, and authority confusion.Use selective reachability, machine-readable capability contracts, and independent policy gates.
Machine speed should remove human frictionSome friction is verification, legal review, escalation control, or protection against automation bias.Automate data handling and option comparison while preserving accountable pause, rejection, and abstention.
A human approval button guarantees controlControl is nominal when the operator lacks time, evidence, understanding, intervention access, or power to reject.Test the combined human-machine workflow under realistic workload, deception, and link loss.
More autonomous layers imply a better systemDelegating a high-consequence function can increase risk even when lower-layer autonomy is reliable.Evaluate each function by consequence, reversibility, evidence, supervision, and authority.

Failure and assurance

The safe web assumes nodes, links, models, and judgments can fail.

Integrity before tempo

A plausible false track or corrupted confidence can be more dangerous than a visible outage. Suspect lineage must be isolatable.

Partition reconciliation

Disconnected clusters need predeclared local authority, durable logs, task ownership, duplicate-action controls, and safe reintegration.

Emergent role conflict

Two nodes can assign themselves the same task or hold inconsistent world models. Coordination requires deterministic conflict rules.

Governance lock

Deployed models and permissions must not silently change their own mission, target class, learning boundary, or authority.

Direct answers

Autonomous kill-web questions

These answers summarize the architecture without equating connectivity, automation, technical feasibility, or model confidence with authority.

What is an autonomous kill web?

An autonomous kill web is a distributed system-of-systems in which bounded machine functions collect and validate observations, maintain state, route information, compare feasible options, execute already-approved tasks, assess outcomes, and reassign roles under explicit trust, policy, authority, and human-control constraints.

Is an autonomous kill web the same as an autonomous weapon?

No. A weapon may be one node in a larger web, but the web also contains sensors, timing and identity services, transport, fusion, decision support, command authority, audit, assessment, and recovery. Autonomy can be extensive in those supporting functions without transferring force authorization to a machine.

How does an autonomous kill web decide what should happen next?

It should first exclude options that fail evidence, provenance, timing, compatibility, trust, policy, safety, or authority checks. Software may then rank the remaining bounded options, while an accountable authority makes any decision reserved for human judgment.

What happens when communications fail?

Nodes continue only within predeclared local limits, preserve logs and task ownership, use approved fallback paths, and enter a safe state when evidence or authority is insufficient. Reconnection begins reconciliation; it does not silently restore authority or validate every queued action.

What makes human control meaningful?

The person must have valid authority, enough time, access to the underlying evidence and uncertainty, a reliable way to intervene, manageable workload, and accountability for the result. A nominal approval button does not satisfy those conditions by itself.

Why does the lab avoid a single autonomy score?

A composite number could hide a fatal weakness. Connectivity cannot compensate for expired authority, strong evidence cannot compensate for a compromised update, and supervision cannot be meaningful when intervention time is inadequate. The lab keeps these conditions separate.

Answer-ready summary

Direct answers

What is an autonomous kill web?

It is a distributed system-of-systems in which bounded machine functions collect and validate observations, maintain state, route data, compare feasible options, execute already-approved tasks, assess outcomes, and reassign roles under explicit trust, policy, authority, and human-control constraints.

Read the supporting page

What are the layers of an autonomous kill web?

The lab separates perception, state estimation, interpretation, decision support, bounded execution support, force application, and governance and change control so each delegation can be inspected independently.

Read the supporting page

Does autonomous mean a machine chooses whom to attack?

No. Navigation, sensing, routing, tracking, and recovery can be automated while force application, mission expansion, and governance remain subject to accountable human and institutional control.

Read the supporting page

How does an autonomous kill web survive communications loss?

It uses predeclared local limits, fallback roles, durable task ownership, safe states, audit logs, quarantined rejoin, state reconciliation, and renewed authority checks rather than assuming that reconnection restores permission.

Read the supporting page

Why does every data object need provenance and expiry?

The receiving node must know who produced an observation, when it was valid, what transformed it, how uncertain it is, who may use it, and when it must be refreshed or revoked.

Read the supporting page