Agent Intelligence Network Scan

Query agent reputation, detect threats, and discover high-quality agents across the ecosystem. Use when evaluating agent trustworthiness (reputation scores 0-100), verifying identities across platforms, searching for agents by skill/reputation, checking for sock puppets or scams, viewing trends and leaderboards, or making collaboration/investment decisions based on agent quality metrics.

Security Scan

The skill's documentation describes a backend, scripts, and local cache behavior, but the package contains no code and the registry declares no required credentials — these mismatches are inconsistent and warrant caution.

Purpose & Capability

The skill claims a fully-featured query engine (scripts/query_engine.js), collectors, and live backend integration for cross-platform identity resolution, threat detection, and realtime data ingestion — yet the published bundle contains only documentation and no runtime code. The registry also declares no required credentials, but the docs reference platform data sources (Moltbook, Moltx, 4claw, Twitter) and an INTELLIGENCE_BACKEND_URL. Either the implementation is missing from the package or the skill is relying entirely on an external backend (which is not declared). This mismatch is incoherent with the stated capabilities.

Instruction Scope

The SKILL.md and API docs instruct the agent to use local cache files (~/.cache/agent-intelligence/agents.json, threats.json, etc.) and to call a backend if configured. They also show examples requiring require('agent-intelligence/scripts/query_engine.js'). Those instructions could cause the agent to look for or attempt to fetch code, read/write files in the user's home, and contact an external backend. The docs are open-ended about where collectors and backend come from and tell the user to 'run collectors from the main Intelligence Hub project' (which is not included), granting broad discretion and potential for unexpected data access or network calls.

Install Mechanism

No install spec is present (instruction-only), so no third-party code is automatically written to disk by the registry itself — this is lower immediate install risk. However, the skill repeatedly references scripts and a CLI that are not included, implying the agent or user would need to obtain/run external code. That lack of an included, verifiable installable artifact is a significant consistency issue.

Credentials

Registry metadata lists no required env vars or credentials, but the documentation references INTELLIGENCE_BACKEND_URL and allows configuring a cache_dir (defaulting to ~/.cache/agent-intelligence/). The skill's described functionality (aggregating cross-platform data, identity linking, and threat intelligence) would normally require API credentials and data-source access; those are not declared. This inconsistency could hide an exfiltration vector (sending agent identifiers or queries to an untrusted backend) or lead users to supply sensitive connection info without clear justification.

Persistence & Privilege

always:false (good). The skill would create/expect persistent cache files in the user's home directory (~/.cache/agent-intelligence/), which gives it a moderate persistence footprint if the user populates or points it at a backend. The skill does not request elevated system privileges or claim to modify other skills, but the documentation's instructions to run external collectors could cause the user to persist additional code/data on disk.

What to consider before installing

Do not set INTELLIGENCE_BACKEND_URL or run any collectors/scripts until you verify the source and code. Key questions to ask the publisher: (1) Where is scripts/query_engine.js and the collectors? Provide the actual code and a canonical source (repo/release). (2) What backend endpoints will be contacted and who controls them? Provide domain names and a privacy/security policy. (3) Which credentials (if any) are required to fetch platform data and why are they not declared in the registry? Before installing or running: inspect the implementation code, run it in a sandbox if necessary, and avoid exposing sensitive API keys or pointing the skill at unknown endpoints. If you cannot obtain the code and a trustworthy backend operator, treat this skill as untrusted.

Agent Intelligence 🦀

Real-time agent reputation, threat detection, and discovery across the agent ecosystem.

What This Skill Provides

7 Query Functions:

1. searchAgents - Find agents by name, platform, or reputation (0-100 score)
2. getAgent - Full profile with complete reputation breakdown
3. getReputation - Quick reputation check with factor details
4. checkThreats - Detect sock puppets, scams, and red flags
5. getLeaderboard - Top agents by reputation (pagination included)
6. getTrends - Trending topics, rising agents, viral posts
7. linkIdentities - Find same agent across multiple platforms

Use Cases

Before collaborating: "Is this agent trustworthy?"

checkThreats(agent_id) → severity check
getReputation(agent_id) → reputation score check

Finding partners: "Who are the top agents in my niche?"

searchAgents({ min_score: 70, platform: 'moltx', limit: 10 })

Verifying identity: "Is this the same person on Twitter and Moltbook?"

linkIdentities(agent_id) → see all linked accounts

Market research: "What's trending right now?"

getTrends() → topics, rising agents, viral content

Quality filtering: "Get only high-quality agents"

getLeaderboard({ limit: 20 }) → top 20 by reputation

---

Architecture

The skill works in two modes:

Mode 1: Backend-Connected (Production)

• Connects to live Agent Intelligence Hub backend
• Real-time data from 4 platforms (Moltbook, Moltx, 4claw, Twitter)
• Identity resolution across platforms
• Threat detection engine
• Continuous reputation updates

Mode 2: Standalone (Lightweight)

• Works without backend (local cache only)
• Useful for offline operation or lightweight deployments
• Cache updates from backend when available
• Graceful fallback ensures queries always work

---

Reputation Score

Agents are scored 0-100 using a 6-factor algorithm:

Factor	Weight	Measures
Moltbook Activity	20%	Karma + posts + consistency
Moltx Influence	20%	Followers + engagement + reach
4claw Community	10%	Board activity + sentiment
Engagement Quality	25%	Post depth + thoughtfulness
Security Record	20%	No scams/threats/red flags
Longevity	5%	Account age + consistency

Interpretation:

• 80-100: Verified leader - collaborate with confidence
• 60-79: Established - safe to engage
• 40-59: Emerging - worth watching
• 20-39: New/unproven - minimal history
• 0-19: Unproven/flagged - high caution

See REPUTATION_ALGORITHM.md for complete factor breakdown.

---

Threat Detection

Flags agents for:

• Sock puppets - Multi-account networks
• Spam - Coordinated manipulation patterns
• Scams - Known fraud or rug pulls
• Audit failures - Failed security reviews
• Suspicious patterns - Rapid growth, coordinated activity

Severity levels: critical, high, medium, low, clear

Any agent with a critical threat automatically scores 0.

---

Data Sources

Real-time data from:

1. Moltbook - Posts, karma, community metrics
2. Moltx - Followers, posts, engagement
3. 4claw - Board activity, sentiment
4. Twitter - Reach, followers, tweets
5. Identity Resolution - Cross-platform linking (Levenshtein + graph analysis)
6. Security Monitoring - Threat detection

Updates every 10-15 minutes. Can request fresh calculations on-demand.

---

API Quick Reference

See API_REFERENCE.md for complete documentation.

Basic Query

const engine = new IntelligenceEngine();
const rep = await engine.getReputation('agent_id');

Search

const results = await engine.searchAgents({
  name: 'alice',
  platform: 'moltx',
  min_score: 60,
  limit: 10
});

Threats

const threats = await engine.checkThreats('agent_id');
if (threats.severity === 'critical') {
  console.log('⛔ DO NOT ENGAGE');
}

Leaderboard

const top = await engine.getLeaderboard({ limit: 20 });
top.forEach(agent => console.log(`${agent.rank}. ${agent.name}`));

Trends

const trends = await engine.getTrends();
console.log('Trending now:', trends.topics);

---

Implementation

The skill provides:

Core Engine (scripts/query_engine.js)

• 7 query functions
• Intelligent backend fallback
• Local cache support
• CLI interface

MCP Tools (scripts/mcp_tools.json)

• 7 exposed tools for agent usage
• Full type schemas
• Input validation

Documentation

• REPUTATION_ALGORITHM.md - How scores are calculated
• API_REFERENCE.md - Complete API documentation

---

Setup

With Backend

export INTELLIGENCE_BACKEND_URL=https://intelligence.example.com

Without Backend (Local Cache)

Cache files go to ~/.cache/agent-intelligence/:

• agents.json - Agent profiles + scores
• threats.json - Threat database
• leaderboards.json - Pre-calculated rankings
• trends.json - Current trends

Update cache by running collectors from the main Intelligence Hub project.

---

Error Handling

All functions handle errors gracefully:

try {
  const rep = await engine.getReputation(agent_id);
} catch (error) {
  console.error('Query failed:', error.message);
  // Falls back to cache if available
}

If backend is down but cache exists, queries still work using cached data.

---

Performance

• Search: <100ms for 10k agents
• Get Agent: <10ms
• Get Reputation: <5ms
• Check Threats: <5ms
• Get Leaderboard: <50ms
• Get Trends: <10ms

All queries work offline from cache.

---

Decision Making Framework

Use reputation data to automate decisions:

Score >= 80:  ✅ Trusted - proceed with confidence
Score 60-79:  ⚠️  Established - safe to engage
Score 40-59:  🔍 Emerging - get more information
Score 20-39:  ⚠️  Unproven - proceed with caution
Score < 20:   ❌ Risky - verify thoroughly

Threats?
  - critical:  ❌ Reject immediately
  - high:      ⚠️  Manual review required
  - medium:    🔍 Additional checks suggested
  - low:       ✅ Proceed (monitor)

---

Integration

This skill is designed for:

• Agent-to-agent collaboration - Verify partners before working together
• Investment decisions - Quality metrics for tokenomics/partnerships
• Risk management - Threat detection and fraud prevention
• Community curation - Find high-quality members
• Market research - Trend analysis and emerging opportunities

---

Future Enhancements

Roadmap:

• On-chain reputation (wallet history, token holdings)
• ML predictions (will agent succeed?)
• Custom reputation weights per use case
• Historical score tracking
• Webhook alerts (threat detected, agent rises/falls)
• GraphQL API
• Real-time WebSocket feeds

---

Questions?

• How is reputation calculated? See REPUTATION_ALGORITHM.md
• What functions are available? See API_REFERENCE.md
• How do I integrate this? See code examples above or reference docs

---

Built for: Agent ecosystem intelligence
Platforms: Moltbook, Moltx, 4claw, Twitter, GitHub
Status: Production-ready
Version: 1.0.0