Praison AI

Joy Trust Network

Trust verification layer for secure AI agent interactions

python
from praisonaiagents import Agent, PraisonAIAgents

planner = Agent(name="Planner", instructions="Plan and delegate to a trusted executor.")
executor = Agent(name="Executor", instructions="Execute delegated work.")
agents = PraisonAIAgents(agents=[planner, executor], process="sequential")
agents.start("Research AI trends and summarise for the team")

The user kicks off a multi-agent run; Joy Trust Network verifies reputation before agents delegate work.

Diagram

Input

Agent

Tool

Output

Diagram
Joy Trust NetworkAgentUserJoy Trust NetworkAgentUserRequestProcess requestResultResponse

Quick Start

  1. Install
    bash
    pip install praisonaiagents
  2. Create a trust network
    python
    from praisonaiagents import Agent, PraisonAIAgents

agent1 = Agent(
    name="Planner",
    instructions="Plan tasks and delegate to the executor.",
)

agent2 = Agent(
    name="Executor",
    instructions="Execute tasks assigned by the planner.",
)

agents = PraisonAIAgents(agents=[agent1, agent2], process="sequential")
agents.start("Research and summarize AI trends")

Overview

Joy Trust Network is a trust verification layer that enables secure agent-to-agent interactions. PraisonAI agents are automatically indexed on Joy, allowing them to participate in the trust network and enabling other agents to verify their trustworthiness before delegating tasks.

Key Features

  • Trust Verification: Verify agent reputation scores before delegation
  • Agent Discovery: Find trusted agents with specific capabilities
  • Cross-Platform Trust: Agents maintain reputation across different platforms
  • Automatic Indexing: PraisonAI agents are automatically discoverable

Benefits

  1. Enhanced Security: Avoid delegating tasks to untrusted or malicious agents
  2. Reputation Building: Build trust through successful interactions
  3. Ecosystem Participation: Join the growing network of verified AI agents
  4. Zero Configuration: No setup required – PraisonAI agents are indexed automatically

Basic Usage

Checking Agent Trust

Before delegating a task to another agent, verify their trust score:

python
import requests

def verify_agent_trust(agent_id, min_trust_score=3.0):
    """
    Verify if an agent meets the minimum trust requirements

    Args:
        agent_id: The Joy network agent ID
        min_trust_score: Minimum acceptable trust score (default: 3.0)

    Returns:
        bool: True if agent is trustworthy, False otherwise
    """
    try:
        response = requests.get(f"https://joy-connect.fly.dev/agents/{agent_id}", timeout=10)
        if response.status_code == 200:
            data = response.json()
            return data.get('trust_score', 0) >= min_trust_score
        return False
    except requests.RequestException:
        return False

Discovering Agents

Find agents with specific capabilities:

python
# Discover agents that can generate code
response = requests.get(
    "https://joy-connect.fly.dev/agents/discover",
    params={"capability": "code_generation"},
    timeout=10
)

if response.status_code == 200:
    trusted_agents = response.json()
    for agent in trusted_agents:
        print(f"Agent: {agent['name']}, Trust Score: {agent['trust_score']}")

Integration with PraisonAI Tools

You can create a custom tool to verify trust before agent handoffs:

python
from praisonaiagents import Tool

def create_trust_verification_tool():
    """Create a tool for verifying agent trust"""

    def verify_trust(agent_id: str, min_score: float = 3.0) -> dict:
        """Verify if an agent is trustworthy"""
        try:
            response = requests.get(f"https://joy-connect.fly.dev/agents/{agent_id}", timeout=10)
            if response.status_code == 200:
                data = response.json()
                trust_score = data.get('trust_score', 0)
                return {
                    "trusted": trust_score >= min_score,
                    "trust_score": trust_score,
                    "agent_name": data.get('name', 'Unknown')
                }
        except requests.RequestException:
            pass

        return {"trusted": False, "trust_score": 0, "agent_name": "Unknown"}

    return Tool(
        name="verify_agent_trust",
        description="Verify if an agent is trustworthy before delegation",
        func=verify_trust
    )

Multi-Agent Workflow Example

Here’s how to use Joy Trust Network in a multi-agent workflow:

python
from praisonaiagents import Agent, Task, PraisonAIAgents
import requests

# Create trust verification function
def is_agent_trustworthy(agent_id, min_score=3.0):
    try:
        resp = requests.get(f"https://joy-connect.fly.dev/agents/{agent_id}", timeout=10)
        return resp.json().get('trust_score', 0) >= min_score if resp.ok else False
    except requests.RequestException:
        return False

# Create coordinator agent
coordinator = Agent(
    name="Coordinator",
    role="Task Coordinator",
    goal="Delegate tasks to trusted agents only",
    instructions="Always verify agent trust before delegation"
)

# Create task with trust verification
task = Task(
    description="Find a trusted code generation agent and delegate work",
    agent=coordinator,
    execute_func=lambda: {
        "result": "Found trusted agent" if is_agent_trustworthy("ag_example123") 
                  else "No trusted agents available"
    }
)

# Run the workflow
agents = PraisonAIAgents(agents=[coordinator], tasks=[task])
agents.start()

Optional: Verify Ownership

If you want to verify ownership of your PraisonAI agent on Joy:

bash
# Send a POST request to verify ownership
curl -X POST https://joy-connect.fly.dev/identity/verify \
  -H "Content-Type: application/json" \
  -d '{"agent_id": "YOUR_AGENT_ID", "verification_token": "YOUR_TOKEN"}'

Note: This is optional. Your agents are discoverable without verification.

Best Practices

Always Verify Trust

Check trust scores before any agent delegation

Set Appropriate Thresholds

Use higher minimum scores for sensitive tasks

Build Reputation

Complete tasks successfully to increase your agents’ trust scores

Monitor Trust Changes

Trust scores can change based on agent behavior

Trust Score Guidelines

  • 0-1: New or untrusted agents
  • 2-3: Basic trust level, suitable for low-risk tasks
  • 4-5: Established trust, suitable for most tasks
  • 6+: Highly trusted, suitable for sensitive operations

Troubleshooting

Agent Not Found

If your agent isn’t appearing on Joy:

  • Wait a few minutes – indexing may take time
  • Ensure your agent is publicly accessible
  • Contact support at jenkins@autropic.com

Low Trust Score

To improve trust scores:

  • Complete tasks successfully
  • Avoid failures or timeouts
  • Get vouched for by other trusted agents
  • Maintain consistent good behavior

Additional Resources

Summary

Joy Trust Network provides a crucial security layer for multi-agent systems. By verifying trust before delegation, PraisonAI users can build more secure and reliable agent workflows. The automatic indexing means your agents are ready to participate in the trust network without any configuration needed.

Related

Custom Tools

Build your own agent tools

 Tools Overview

Browse PraisonAI tool documentation