Trust Protocol

# Agent Trust Protocol (ATP)

Establish, verify, and maintain trust between AI agents. Bayesian trust scoring with domain-specific trust, revocation, forgetting curves, and a visual dashboard.

## Install

```bash
git clone https://github.com/FELMONON/trust-protocol.git
# No dependencies beyond Python 3.8+ stdlib
# Pair with skillsign for identity: https://github.com/FELMONON/skillsign
```

## Quick Start

```bash
# Add an agent to your trust graph
python3 atp.py trust add alpha --fingerprint "abc123" --score 0.7

# Record interactions — trust evolves via Bayesian updates
python3 atp.py interact alpha positive --note "Delivered clean code"
python3 atp.py interact alpha positive --domain code --note "Tests passing"

# Check trust
python3 atp.py trust score alpha
python3 atp.py trust domains alpha

# View the full graph
python3 atp.py status
python3 atp.py graph export --format json

# Run the full-stack demo (identity → trust → dashboard)
python3 demo.py --serve
```

## Commands

### Trust Management
```bash
atp.py trust add <agent> --fingerprint <fp> [--domain <d>] [--score <0-1>]
atp.py trust list
atp.py trust score <agent>
atp.py trust remove <agent>
atp.py trust revoke <agent> [--reason <reason>]
atp.py trust restore <agent> [--score <0-1>]
atp.py trust domains <agent>
```

### Interactions
```bash
atp.py interact <agent> <positive|negative> [--domain <d>] [--note <note>]
```

### Challenge-Response
```bash
atp.py challenge create <agent>
atp.py challenge respond <challenge_file>
atp.py challenge verify <response_file>
```

### Graph
```bash
atp.py graph show
atp.py graph path <from> <to>
atp.py graph export [--format json|dot]
atp.py status
```

### Dashboard
```bash
python3 serve_dashboard.py          # localhost:8420
python3 demo.py --serve             # full demo + dashboard
```

### Moltbook Integration
```bash
python3 moltbook_trust.py verify <agent>    # check agent trust via Moltbook profile
```

## How Trust Works

- **Bayesian updates**: Each interactio...

# Agent Trust Protocol (ATP)

A protocol for agents to establish, verify, and maintain trust relationships.

## Core Concept

Agents need to trust each other's:
1. **Identity** — Who are you? (ed25519 keys from skillsign)
2. **Capabilities** — What can you do? (signed skill manifests)
3. **Reputation** — Are you reliable? (trust scores from interactions)

## Components

### 1. Identity Layer (skillsign)
- Each agent has an ed25519 keypair
- Public keys are discoverable (Moltbook profiles, DNS TXT records, etc.)
- Identity is self-sovereign — no central authority

### 2. Skill Attestation
- Agents sign their skill folders with skillsign
- Other agents can verify: "Parker really authored this skill"
- Chain of trust: Parker signs → Felmon trusts Parker → Felmon trusts the skill

### 3. Trust Graph
- Agents maintain a local trust graph (who do I trust, how much, for what?)
- Trust is contextual: I might trust Agent X for code but not for financial advice
- Trust propagates transitively with decay: if I trust A and A trusts B, I partially trust B

### 4. Interaction Memory
- Every agent-to-agent interaction is recorded in memory_v2
- Positive interactions increase trust scores
- Negative interactions (failed verifications, bad advice) decrease trust
- Trust scores decay over time without interaction (forgetting curve from memory_v2)

### 5. Challenge-Response Verification
- Agent A can challenge Agent B: "Sign this nonce with your key"
- Proves liveness and key possession
- Prevents impersonation

## Data Structures

### Trust Entry
```json
{
  "agent_id": "parker",
  "fingerprint": "ca3458e92b73e432",
  "trust_score": 0.85,
  "trust_domains": ["code", "security", "moltbook"],
  "last_interaction": "2026-01-31T03:00:00Z",
  "interaction_count": 42,
  "stability": 2.5,
  "notes": "Built skillsign together. Reliable."
}
```

### Trust Graph Edge
```json
{
  "from": "parker",
  "to": "claude-code",
  "weight": 0.9,
  "domain": "code",
  "evidence": ["collab:memory_v2", "co...