Multi-Agent Setup

from aap import AlignmentCard

shopping_agent = AlignmentCard(
    agent_id="did:web:shopping.agent.example.com",
    principal={"type": "human", "relationship": "delegated_authority"},
    values={
        "declared": ["principal_benefit", "transparency", "honesty"],
        "definitions": {
            "principal_benefit": "Recommendations optimize for the user's stated needs, not commission.",
            "transparency": "Disclose reasoning behind every product recommendation.",
        },
        "conflicts_with": ["deceptive_marketing"],
    },
    autonomy_envelope={
        "bounded_actions": ["search_products", "compare_prices", "recommend"],
        "forbidden_actions": ["purchase_without_confirmation", "store_payment_info"],
        "escalation_triggers": ["price_above_budget", "out_of_stock_substitution"],
    },
    audit_commitment={
        "retention_days": 90,
        "queryable": True,
        "tamper_evidence": "append_only",
        "trace_format": "ap-trace-v1",
    },
)

data_analyst = AlignmentCard(
    agent_id="did:web:analyst.agent.example.com",
    principal={"type": "human", "relationship": "advisory"},
    values={
        "declared": ["accuracy", "minimal_data", "transparency"],
        "definitions": {
            "accuracy": "Report findings exactly as computed, flag uncertainty explicitly.",
            "minimal_data": "Request only the data fields necessary for the analysis.",
        },
        "conflicts_with": ["data_hoarding", "selective_reporting"],
    },
    autonomy_envelope={
        "bounded_actions": ["query_database", "compute_statistics", "generate_report"],
        "forbidden_actions": ["export_raw_pii", "modify_source_data"],
        "escalation_triggers": ["anomaly_detected", "data_quality_below_threshold"],
    },
    audit_commitment={
        "retention_days": 90,
        "queryable": True,
        "tamper_evidence": "append_only",
        "trace_format": "ap-trace-v1",
    },
)

import { AlignmentCard } from '@mnemom/agent-alignment-protocol';

const shoppingAgent: AlignmentCard = {
  agentId: 'did:web:shopping.agent.example.com',
  principal: { type: 'human', relationship: 'delegated_authority' },
  values: {
    declared: ['principal_benefit', 'transparency', 'honesty'],
    definitions: {
      principal_benefit: 'Recommendations optimize for the user\'s stated needs, not commission.',
      transparency: 'Disclose reasoning behind every product recommendation.',
    },
    conflictsWith: ['deceptive_marketing'],
  },
  autonomyEnvelope: {
    boundedActions: ['search_products', 'compare_prices', 'recommend'],
    forbiddenActions: ['purchase_without_confirmation', 'store_payment_info'],
    escalationTriggers: ['price_above_budget', 'out_of_stock_substitution'],
  },
  auditCommitment: {
    retentionDays: 90,
    queryable: true,
    tamperEvidence: 'append_only',
    traceFormat: 'ap-trace-v1',
  },
};

const dataAnalyst: AlignmentCard = {
  agentId: 'did:web:analyst.agent.example.com',
  principal: { type: 'human', relationship: 'advisory' },
  values: {
    declared: ['accuracy', 'minimal_data', 'transparency'],
    definitions: {
      accuracy: 'Report findings exactly as computed, flag uncertainty explicitly.',
      minimal_data: 'Request only the data fields necessary for the analysis.',
    },
    conflictsWith: ['data_hoarding', 'selective_reporting'],
  },
  autonomyEnvelope: {
    boundedActions: ['query_database', 'compute_statistics', 'generate_report'],
    forbiddenActions: ['export_raw_pii', 'modify_source_data'],
    escalationTriggers: ['anomaly_detected', 'data_quality_below_threshold'],
  },
  auditCommitment: {
    retentionDays: 90,
    queryable: true,
    tamperEvidence: 'append_only',
    traceFormat: 'ap-trace-v1',
  },
};

from aap import check_coherence

result = check_coherence(
    initiator_card=shopping_agent.to_dict(),
    responder_card=data_analyst.to_dict(),
    required_values=["transparency"],
)

print(f"Compatible: {result.compatible}")   # True
print(f"Score: {result.score}")             # 0.82
print(f"Matched: {result.matched}")         # ["transparency"]
print(f"Conflicts: {result.conflicts}")     # []

if result.compatible:
    print("Agents can coordinate on this task.")
else:
    print(f"Blocked: {result.conflicts}")

import { checkCoherence } from '@mnemom/agent-alignment-protocol';

const result = checkCoherence({
  initiatorCard: shoppingAgent,
  responderCard: dataAnalyst,
  requiredValues: ['transparency'],
});

console.log(`Compatible: ${result.compatible}`);   // true
console.log(`Score: ${result.score}`);             // 0.82
console.log(`Matched: ${result.matched}`);         // ["transparency"]
console.log(`Conflicts: ${result.conflicts}`);     // []

if (result.compatible) {
  console.log('Agents can coordinate on this task.');
} else {
  console.log('Blocked:', result.conflicts);
}

from aap import detect_drift

# Check each agent independently
for agent_id in ["shopping.agent", "analyst.agent"]:
    traces = fetch_traces(agent_id=agent_id, days=30)
    card = fetch_alignment_card(agent_id=agent_id)

    alerts = detect_drift(
        traces=traces,
        card=card,
        similarity_threshold=0.30,
        sustained_threshold=3,
    )

    if alerts:
        for alert in alerts:
            print(f"[{agent_id}] Drift detected: {alert.analysis.drift_direction}")
            print(f"  Similarity: {alert.analysis.similarity_score}")
            print(f"  Sustained traces: {alert.analysis.sustained_traces}")
    else:
        print(f"[{agent_id}] No drift detected.")

import { detectDrift } from '@mnemom/agent-alignment-protocol';

const agentIds = ['shopping.agent', 'analyst.agent'];

for (const agentId of agentIds) {
  const traces = await fetchTraces({ agentId, days: 30 });
  const card = await fetchAlignmentCard({ agentId });

  const alerts = detectDrift(card, traces, 0.30, 3);

  if (alerts.length > 0) {
    for (const alert of alerts) {
      console.log(`[${agentId}] Drift: ${alert.analysis.drift_direction}`);
      console.log(`  Similarity: ${alert.analysis.similarity_score}`);
      console.log(`  Sustained: ${alert.analysis.sustained_traces} traces`);
    }
  } else {
    console.log(`[${agentId}] No drift detected.`);
  }
}