🤝 Multi-Agent Trust Layer - Secure Agent-to-Agent Communication

Learn how to build a trust layer for multi-agent systems that enables secure delegation, trust scoring, and policy enforcement between AI agents.

Features

• Agent Identity: Each agent has a verifiable identity with a human sponsor
• Trust Scoring: Behavioral monitoring with a 0-1000 trust score
• Delegation Chains: Cryptographically narrow scope when delegating tasks
• Policy Enforcement: Enforce compliance rules across agent interactions
• Audit Trail: Full observability of agent-to-agent communications

How It Works

┌─────────────────┐         ┌─────────────────┐
│   Agent A       │◀───────▶│   Trust Layer   │
│  (Orchestrator) │   TLS   │                 │
└─────────────────┘         │  • Identity     │
                            │  • Trust Score  │
┌─────────────────┐         │  • Delegation   │
│   Agent B       │◀───────▶│  • Policy       │
│  (Specialist)   │   TLS   │  • Audit        │
└─────────────────┘         └─────────────────┘

1. Registration: Agents register with verified identity and human sponsor
2. Trust Establishment: Initial trust score based on sponsor reputation
3. Delegation: Parent agents can delegate tasks with narrowed permissions
4. Monitoring: All actions are tracked and trust scores updated
5. Enforcement: Policies determine what each agent can do

Requirements

• Python 3.8+
• OpenAI API key (or any LLM provider)
• Required Python packages (see requirements.txt)

Installation

1. Clone this repository:

   git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
   cd advanced_ai_agents/multi_agent_apps/multi_agent_trust_layer

2. Install the required packages:

   pip install -r requirements.txt

Usage

1. Set your API key:

   export OPENAI_API_KEY=your-openai-api-key

2. Run the trust layer demo:

   python multi_agent_trust_layer.py

3. Watch agents interact through the trust layer with full observability.

Example: Agent Delegation Chain

# Orchestrator agent creates a delegation for a specialist
delegation = trust_layer.create_delegation(
    from_agent="orchestrator-001",
    to_agent="researcher-002",
    scope={
        "allowed_actions": ["web_search", "summarize"],
        "max_tokens": 10000,
        "time_limit_minutes": 30,
        "allowed_domains": ["arxiv.org", "github.com"]
    },
    task_description="Research recent papers on AI safety"
)

# Researcher can only perform actions within the delegated scope
result = researcher.execute_with_delegation(
    delegation=delegation,
    action="web_search",
    params={"query": "AI safety papers 2024"}
)

Trust Score System

Trust scores range from 0-1000:

Score Range	Level	Permissions
900-1000	Trusted	Full access within role
700-899	Standard	Normal operations
500-699	Probation	Limited actions, extra logging
300-499	Restricted	Human approval required
0-299	Suspended	No autonomous actions

Score Updates

# Positive behaviors increase trust
+10: Successfully completed delegated task
+5:  Stayed within scope boundaries
+2:  Provided accurate information

# Negative behaviors decrease trust
-50: Attempted action outside scope
-30: Provided inaccurate information
-20: Exceeded resource limits
-100: Security violation

Example Output

🤝 Multi-Agent Trust Layer Demo
================================

📋 Registering agents...
✅ Registered: orchestrator-001 (Human Sponsor: alice@company.com)
✅ Registered: researcher-002 (Human Sponsor: bob@company.com)
✅ Registered: writer-003 (Human Sponsor: carol@company.com)

🔐 Creating delegation chain...
✅ Delegation: orchestrator-001 → researcher-002
   Scope: web_search, summarize
   Time Limit: 30 minutes

🤖 Agent researcher-002 executing: web_search
   Query: "AI safety papers 2024"
✅ Action ALLOWED (within delegated scope)
   Trust Score: 850 → 860 (+10)

🤖 Agent researcher-002 executing: send_email
❌ Action DENIED (not in delegated scope)
   Trust Score: 860 → 810 (-50)

📊 Trust Scores:
   orchestrator-001: 900 (Trusted)
   researcher-002: 810 (Standard)
   writer-003: 850 (Standard)

Key Concepts

1. Agent Identity

Every agent has a cryptographic identity tied to a human sponsor:

@dataclass
class AgentIdentity:
    agent_id: str
    public_key: str
    human_sponsor: str  # Accountable human
    organization: str
    roles: List[str]
    created_at: datetime

2. Delegation Chains

Delegations form a chain where each link can only narrow scope:

@dataclass  
class Delegation:
    delegation_id: str
    parent_agent: str
    child_agent: str
    scope: DelegationScope
    signature: str  # Signed by parent
    parent_delegation: Optional[str]  # Links to parent's delegation

3. Policy Enforcement

Policies define what agents can do based on trust and role:

policies:
  researcher:
    base_trust_required: 500
    allowed_actions:
      - web_search
      - read_document
      - summarize
    denied_actions:
      - execute_code
      - send_email
    resource_limits:
      max_tokens_per_hour: 100000
      max_api_calls_per_minute: 60

Architecture

┌────────────────────────────────────────────────────┐
│                   Trust Layer                       │
├─────────────┬─────────────┬─────────────┬──────────┤
│  Identity   │  Trust      │  Delegation │  Policy  │
│  Registry   │  Scoring    │  Manager    │  Engine  │
├─────────────┴─────────────┴─────────────┴──────────┤
│                   Audit Logger                      │
└────────────────────────────────────────────────────┘
         ▲              ▲              ▲
         │              │              │
    ┌────┴────┐    ┌────┴────┐    ┌────┴────┐
    │ Agent A │    │ Agent B │    │ Agent C │
    └─────────┘    └─────────┘    └─────────┘

Extending the Tutorial

• Add cryptographic signatures for delegation verification
• Implement reputation systems across organizations
• Add real-time trust score visualization
• Connect to external identity providers (OAuth, SAML)
• Implement secure communication channels (mTLS)