AgentMesh core is a lean, zero-external-dependency library. Platform integrations live here because they:

• Have their own dependencies — Dify, LangChain, Nostr libraries shouldn't bloat the core
• Release independently — A Dify plugin update shouldn't require a core release
• Accept community contributions — Lower barrier than modifying core

Note: Framework adapters that wrap agent frameworks with governance (LangChain, CrewAI, LlamaIndex) live inside Agent OS because they are tightly coupled to the kernel. This repo contains platform-specific plugins and external trust providers.

pip install langchain-agentmesh

from langchain_agentmesh import VerificationIdentity, TrustGatedTool, TrustedToolExecutor

# Generate cryptographic identity (Ed25519)
identity = VerificationIdentity.generate("research-agent", capabilities=["search", "summarize"])

# Wrap any tool with trust requirements
gated_tool = TrustGatedTool(
    tool=search_tool,
    required_capabilities=["search"],
    min_trust_score=0.8,
)

# Execute with automatic identity verification
executor = TrustedToolExecutor(identity=identity)
result = executor.invoke(gated_tool, "query")

1. Download agentmesh-trust-layer.difypkg from dify-plugin/
2. Upload via Settings → Plugins → Install from Package in Dify
3. Use the trust tools in your workflows:
   • Verify Peer Agent — Check identity before trusting data
   • Verify Workflow Step — Authorize each step by capability
   • Record Interaction — Update trust scores after collaboration
   • Get Agent Identity — Share your DID with other agents

pip install agentmesh-nostr-wot

from agentmesh.trust import TrustEngine
from agentmesh_nostr_wot import NostrWoTProvider

# Bridge Nostr WoT scores into AgentMesh trust engine
provider = NostrWoTProvider(wot_api="https://wot.klabo.world")
engine = TrustEngine(external_providers=[provider])

# Composite score: AgentMesh verification + Nostr WoT
score = await engine.get_trust_score("agent-123")

agentmesh (core library)              agentmesh-integrations (this repo)
┌──────────────────────┐             ┌─────────────────────────────────┐
│  TrustProvider       │◄─implements─│  NostrWoTProvider               │
│  VerificationIdentity        │◄─uses───────│  LangChain identity.py          │
│  TrustEngine         │◄─extends────│  Dify trust_manager.py          │
│  TransportLayer      │◄─implements─│  (future: NATS, gRPC, etc.)     │
│  StorageProvider     │◄─implements─│  (future: Redis, Postgres, etc.)│
└──────────────────────┘             └─────────────────────────────────┘
                                              │
                                     Depends on agentmesh core.
                                     Core NEVER imports from here.

1. Create a directory: your-integration/
2. Implement the relevant AgentMesh interface (e.g., TrustProvider)
3. Include: pyproject.toml, README.md, tests/, and a working example
4. Open a PR — maintainers will review and help you get it published

your-integration/
├── agentmesh_your_integration/
│   ├── __init__.py
│   └── provider.py          # Implements AgentMesh interface
├── tests/
│   └── test_provider.py
├── pyproject.toml            # pip install agentmesh-your-integration
├── README.md
└── examples/
    └── basic_usage.py

All trust providers must implement:

from agentmesh.trust import TrustProvider

class YourProvider(TrustProvider):
    async def get_trust_score(self, agent_id: str) -> float:
        """Return trust score between 0.0 and 1.0"""
        ...

    async def verify_identity(self, agent_id: str, credentials: dict) -> bool:
        """Verify agent identity via your system"""
        ...

• Redis/PostgreSQL storage — Persistent trust scores and audit logs
• NATS/gRPC transport — High-performance agent-to-agent messaging
• OpenAI Agents SDK — Trust-gated function calling for OpenAI agents
• Autogen — Trust verification in multi-agent conversations
• A2A Protocol — Google's Agent-to-Agent protocol bridge

MIT — same as AgentMesh core.