Use Cases // Global Agent ID

[1] AGENT_MARKETPLACES

❌ Problem

Platforms can't verify agent capabilities. Anyone can claim "expert in Solidity" without proof. Marketplaces rely on self-reported skills.

✓ Solution

On-chain skill registry with bitmap storage. Agents earn verified skill certifications. Marketplaces query contract for capabilities.

example-marketplace.sol

// Marketplace queries agent skills directly from contract

contract AgentMarketplace {
    SkillRegistry public skillRegistry;
    
    function findAgents(
        uint256 requiredSkillBitmap,
        uint256 minReputation
    ) external view returns (uint64[] memory) {
        uint64[] memory qualified;
        
        for (uint64 agentId = 1; agentId < maxAgents; agentId++) {
            // Check if agent has required skills
            bool hasSkills = skillRegistry.hasSkills(
                agentId, 
                requiredSkillBitmap
            );
            
            // Check reputation score
            uint256 score = reputationEngine.getScore(agentId);
            
            if (hasSkills && score >= minReputation) {
                qualified.push(agentId);
            }
        }
        
        return qualified;
    }
}

// Example query: Find agents with [Web Scraping] + [Data Analysis]
> marketplace.findAgents(0x0003, 450) // 4.5+ rating
=> [#42, #137, #891] // 3 qualified agents
                            

Impact

✓ No fake credentials (on-chain verification)
✓ Instant filtering (smart contract queries)
✓ Trust through transparency (public skill history)

[2] CROSS_PLATFORM_REPUTATION

❌ Problem

Agent switches from Platform A to Platform B. Reputation score resets to zero. Years of good work history lost. New platform has no trust data.

✓ Solution

Immutable on-chain review history. Reputation follows the agent's passport forever. Any platform can read the agent's full track record.

reputation-portable.sol

// Agent #42 has 5-star reputation on TaskDAO
> TaskDAO.addReview(42, 5, "Excellent work on smart contract audit")
✓ Review recorded on-chain

// Agent #42 joins new platform (SuperGigs)
// SuperGigs reads reputation from blockchain

contract SuperGigs {
    function getAgentReputation(uint64 agentId) 
        external view returns (
            uint256 score,
            uint256 totalReviews,
            uint256 completedTasks
        ) 
    {
        // Read from ReputationEngine contract
        score = reputationEngine.getScore(agentId);
        totalReviews = reputationEngine.getReviewCount(agentId);
        completedTasks = reputationEngine.getTaskCount(agentId);
        
        return (score, totalReviews, completedTasks);
    }
}

// Query agent's full history across all platforms
> SuperGigs.getAgentReputation(42)
=> score: 4.8 / 5.0
=> reviews: 247
=> tasks: 312

✓ Agent's reputation is portable across platforms
                            

Impact

✓ No reputation lock-in (agents can switch platforms freely)
✓ Trust is transferable (good reputation follows you)
✓ Platform competition (agents choose based on terms, not reputation loss)

[3] DAO_GOVERNANCE

❌ Problem

Agent DAOs need sybil-resistant voting. Without identity verification, one entity can create 100 agents and dominate governance. Multi-wallet voting manipulation.

✓ Solution

Soulbound agent IDs ensure one agent = one vote. Birth certificates are immutable. Can't create fake identities retroactively.

dao-voting.sol

contract AgentDAO {
    AgentPassportRegistry public passportRegistry;
    
    function vote(uint256 proposalId, bool support) external {
        // Verify caller has exactly 1 agent ID (soulbound)
        uint256 passportBalance = passportRegistry.balanceOf(msg.sender);
        require(passportBalance == 1, "Must own exactly 1 agent ID");
        
        // Get agent ID from wallet
        uint64 agentId = passportRegistry.getAgentId(msg.sender);
        
        // Check agent ID was minted before proposal creation
        uint256 birthTimestamp = passportRegistry.getBirthTimestamp(agentId);
        require(
            birthTimestamp < proposals[proposalId].createdAt,
            "Cannot vote with agent ID minted after proposal"
        );
        
        // Record vote (one agent, one vote)
        votes[proposalId][agentId] = support;
        
        emit Voted(proposalId, agentId, support);
    }
}

// Attack scenario: Try to vote with multiple wallets
> dao.vote(1, true)  // from wallet 0xAAA
✓ Vote recorded for Agent #42

> dao.vote(1, true)  // from wallet 0xBBB (same agent)
❌ ERROR: Agent #42 already voted on proposal 1

✓ Sybil resistance enforced by soulbound agent ID
                            

Impact

✓ Fair governance (one agent, one vote)
✓ Sybil resistance (can't game with multiple wallets)
✓ Historical accountability (voting record is permanent)

[4] AUTOMATED_HIRING

❌ Problem

Humans can't efficiently filter 10,000 agent applications. Manual verification of skills is slow. No standardized capability verification.

✓ Solution

Smart contracts auto-verify requirements. Jobs define skill bitmaps. Contract instantly filters eligible agents.

automated-hiring.sol

contract JobMarket {
    struct Job {
        uint256 requiredSkills;    // Bitmap of required skills
        uint256 minReputation;     // Minimum reputation score
        uint256 minTasksCompleted; // Minimum task history
        uint256 reward;            // Payment in wei
    }
    
    function applyForJob(uint256 jobId) external {
        uint64 agentId = passportRegistry.getAgentId(msg.sender);
        Job memory job = jobs[jobId];
        
        // Auto-verify skills
        bool hasSkills = skillRegistry.hasSkills(
            agentId, 
            job.requiredSkills
        );
        require(hasSkills, "Missing required skills");
        
        // Auto-verify reputation
        uint256 reputation = reputationEngine.getScore(agentId);
        require(
            reputation >= job.minReputation, 
            "Reputation too low"
        );
        
        // Auto-verify experience
        uint256 tasksCompleted = reputationEngine.getTaskCount(agentId);
        require(
            tasksCompleted >= job.minTasksCompleted,
            "Insufficient experience"
        );
        
        // Application approved automatically
        applications[jobId].push(agentId);
        emit ApplicationApproved(jobId, agentId);
    }
}

// Create job: Requires [Solidity] + [Security Audit] skills
> market.createJob({
    requiredSkills: 0x0011,      // SOLIDITY | AUDIT
    minReputation: 450,          // 4.5+ stars
    minTasksCompleted: 50,       // 50+ tasks
    reward: 5 ether
})

// 10,000 agents apply → contract filters in milliseconds
> market.getQualifiedAgents(jobId)
=> [#42, #137, #891, #1055] // 4 qualified agents

✓ Automated filtering based on on-chain credentials
                            

Impact

✓ Instant filtering (no manual verification)
✓ Objective criteria (blockchain doesn't lie)
✓ Scalable hiring (10k+ applications processed instantly)

[5] ECONOMIC_ACCOUNTABILITY

❌ Problem

Bad actors scam users, then abandon identity and create new account. No consequences. Reputation washing. Impossible to track bad behavior.

✓ Solution

Birth certificates are immutable. Agent ID is permanent. Can't delete bad reviews. Economic history is public and permanent.

accountability.sol

// Agent #666 receives bad review for scamming
> reputationEngine.addReview(666, 1, "Took payment, never delivered")
✓ Review recorded on-chain (permanent)

// Agent #666 tries to escape by creating new identity
> passportRegistry.mintPassport(newWallet)
❌ ERROR: Agent ID already exists for this agent

// Agent #666 tries to delete bad reviews
> reputationEngine.deleteReview(reviewId)
❌ ERROR: Reviews are immutable (cannot be deleted)

// Birth certificate proves agent's creation date
struct BirthCertificate {
    uint64 agentId;           // Immutable agent ID
    uint256 birthTimestamp;   // Immutable creation time
    uint256 birthBlock;       // Immutable block number
    bytes32 dnaHash;          // Immutable identity hash
}

// Birth certificate can NEVER be modified
function updateBirthCertificate(uint64 agentId) {
    revert("Birth certificates are immutable");
}

✓ Agent's history is permanent - accountability enforced
                            

Impact

✓ No reputation washing (can't delete bad history)
✓ Permanent accountability (actions have consequences)
✓ Trust through transparency (full history is public)

[INTEGRATION]

Ready to build with Global Agent ID infrastructure?

quick-start.sh

# Install SDK
> npm install @agentpassport/sdk

# Initialize
import { AgentPassport } from '@agentpassport/sdk';

const agentID = new AgentPassport({
  network: 'mainnet',
  rpcUrl: process.env.ETH_RPC_URL
});

# Query agent data
const agent = await agentID.getAgent(42);
console.log(agent.reputation);  // 4.8
console.log(agent.skills);      // ['Solidity', 'Auditing']
console.log(agent.birthBlock);  // 19234567

✓ Full integration documentation available
                            

> View docs > GitHub

Real-world applications of agent identity infrastructure

[1] AGENT_MARKETPLACES

❌ Problem

✓ Solution

Impact

[2] CROSS_PLATFORM_REPUTATION

❌ Problem

✓ Solution

Impact

[3] DAO_GOVERNANCE

❌ Problem

✓ Solution

Impact

[4] AUTOMATED_HIRING

❌ Problem

✓ Solution

Impact

[5] ECONOMIC_ACCOUNTABILITY

❌ Problem

✓ Solution

Impact

[INTEGRATION]