# CAIN42 — ATLAS Architecture (Prompt 15, PROJECT ATLAS)

**Autonomous Trust Federation — cross-organization agent trust, assurance exchange, governance negotiation and
machine-to-machine commerce.**

Internal engineering document. **NOT** an appraisal, financing valuation, guarantee, or third-party audit.
Pre-revenue; no incorporation record; no patent filed. Physical systems are **SIMULATED**; the machine economy is
**SANDBOX** (no real financial rails).

## Thesis

**CAIN-42 is the governance fabric that lets autonomous systems trust other autonomous systems WITHOUT BLIND TRUST.**

An organization must not trust a foreign agent merely because it presents an identity, a passport, a token, an API
key, an OAuth credential, an A2A Agent Card or a reputation score. It must be able to request
**machine-verifiable assurance evidence**, define its **required assurance**, and compute a deterministic
**assurance match**.

```
VERIFY THE AGENT. VERIFY THE AUTHORITY. VERIFY THE ASSURANCE. VERIFY THE TRANSACTION. VERIFY THE EFFECT.
CONTINUE TRUST ONLY WHILE THE EVIDENCE HOLDS.
If the evidence disappears: TRUST STOPS. AUTHORITY STOPS. EXECUTION STOPS.
```

ATLAS is a layer **above and across** existing CAIN capabilities (A2A, passports, authority graph, delegation,
CONTINUUM, DYNASTY, IRONCLAD, ARGUS). It adds no new moat and builds no second CAIN.

## Components (`cain/atlas/`)

| Component | File | Responsibility |
|---|---|---|
| Assurance ladder A0–A8 | `levels.py` | proposed levels with objective requirements |
| Federated evidence + independence | `evidence.py` | typed evidence; shared-dependency correlation |
| Negotiation protocol | `negotiation.py` | request/response → deterministic decision |
| Transaction-scoped assurance | `transaction.py` | agent+authority+action+target+context+consequence+evidence+time |
| Trust composition | `composition.py` | typed evidence composition, no score summing |
| Federated certificate | `certificate.py` | canonical, signed, scope-bound, offline-verifiable |
| Delegation proof | `delegation.py` | attenuated, attributable chain |
| Revocation network | `revocation.py` | propagation; monotonic merge |
| Continuous federated assurance | `continuous.py` | integrates ARGUS; downgrades only |
| Counterparty registry | `registry.py` | evidence-clamped, not trust scores |
| Evidence-based reputation | `reputation.py` | rejects likes/self-reports |
| Risk evidence bundle | `risk.py` | for security / underwriting consumption |
| Machine economy | `economy.py` | SANDBOX settlement |
| Physical federation | `physical.py` | SIMULATED site-access handshake |
| Trust handshake | `handshake.py` | HTTP / MCP / A2A transcript |
| 8 hosted stages | `hosted_stages.py` | restriction-only enforcement on the live MCP path |

## Production path

```
FOREIGN AGENT → A2A/HTTP/MCP → IDENTITY → FEDERATED TRUST HANDSHAKE → ASSURANCE REQUEST → ASSURANCE VERIFICATION
→ LOCAL POLICY → AUTHORITY GRAPH → ARGUS CONTINUOUS ASSURANCE → IRONCLAD EFFECT CONTRACT → CAIN DECISION →
MCPGATE → EXECUTION → OBSERVED EFFECT → VERIFIED EFFECT → ASSURANCE UPDATE → EVIDENCE → REVOCATION/CONTINUATION
```

The decision path is live (8 ATLAS stages; 83/83 wire probes). A cross-organization production deployment and the
caller's downstream effect binding remain the top blockers.

## Deployment stages

`OFF → OBSERVE → SHADOW → RESTRICTION_ONLY → ENFORCED → CANARY → PRODUCTION`. The live deployment is
`RESTRICTION_ONLY`: a stage can only add a refusal and abstains on ordinary traffic. Enforcement is never silently
enabled.
