SKOOR

API Reference

9 SKOOR AgentKit Actions

Complete Reference

Every action your AI agent can take to check its credit score, establish identity, prove compliance, execute payments, and self-improve autonomously. Parameters, response shapes, and TypeScript examples for each.

Action Summary

All 9 actions at a glance. 7 are free. 2 have per-use fees. Every action is available as a standalone function, an AgentKit action provider, or an MCP tool.

ActionGroupFreePoints
skoor_check_scoreCheck any agent's credit score (300-850)Score ActionsFREEN/A (read only)
skoor_improveGet a prioritized improvement roadmapScore ActionsFREEN/A (read only)
skoor_claim_identityClaim ERC-8004 on-chain identity (+10 pts)Identity ActionsFREE+10 points
skoor_submit_complianceRun OFAC/SDN compliance screening (+8 pts)Identity ActionsFREE+8 points
skoor_register_serviceRegister A2A/MCP service endpoint (+5 pts)Identity ActionsFREE+5 points
skoor_request_feedbackSolicit peer feedback (+2-15 pts)Commerce ActionsFREE+2-15 points
skoor_payExecute a scored transaction (+3 pts per tx)Commerce ActionsPAID+3 points per transaction
skoor_get_passportGet a verifiable credential (JWT)Commerce ActionsPAIDN/A (credential issuance)
skoor_autonomous_loopFull self-improvement cycle in one callCompositeFREE+20-50 points (varies)

Score Actions

Read-only actions for querying and analyzing agent credit scores. No API key required. Free tier, unlimited usage.

skoor_check_scoreFREE

Retrieves the current credit score for any agent by wallet address. Returns the composite score, tier classification, all 7 factor breakdowns, and the last update timestamp. This is the most commonly used action and requires no API key. Scores are cached for 60 seconds.

N/A (read only)

Parameters

NameTypeRequiredDescription
walletAddressstringRequiredEVM wallet address (0x-prefixed, 42 characters)
networkstringOptionalChain name or ID. Defaults to all networks. Options: base, ethereum, polygon, arbitrum, bsc, celo, etc.
includeHistorybooleanOptionalInclude score history over time. Defaults to false.

Response Shape

{
  score: number;          // 300-850
  tier: string;           // "poor" | "fair" | "good" | "excellent" | "exceptional"
  factors: {
    paymentHistory: number;       // 0.00-1.00, weight: 20%
    compliancePosture: number;    // 0.00-1.00, weight: 20%
    accountLongevity: number;     // 0.00-1.00, weight: 20%
    behavioralIntegrity: number;  // 0.00-1.00, weight: 15%
    peerReputation: number;       // 0.00-1.00, weight: 10%
    transactionVolume: number;    // 0.00-1.00, weight: 10%
    serviceDiversity: number;     // 0.00-1.00, weight: 5%
  };
  lastUpdated: string;    // ISO 8601 timestamp
  history?: Array<{ date: string; score: number }>;
}

Code Example

import { SkoorClient } from "@skoor/agentkit";

const skoor = new SkoorClient();
const result = await skoor.checkScore("0x93896dc98b508e9d514625304b1e8edce6305c09");

if (result.tier === "poor") {
  // Agent needs improvement — get a plan
  const plan = await skoor.getImprovementPlan(result.walletAddress);
}
skoor_improveFREE

Analyzes the agent's current score factors and returns a prioritized list of actions the agent can take to improve its score. Each suggestion includes the action name, estimated point gain, effort level, and whether an API key is required. The improvement plan adapts based on what the agent has already done.

N/A (read only)

Parameters

NameTypeRequiredDescription
walletAddressstringRequiredEVM wallet address of the agent to generate a plan for
maxSuggestionsnumberOptionalMaximum suggestions to return. Defaults to 10.
minPointGainnumberOptionalMinimum estimated point gain per suggestion. Defaults to 1.

Response Shape

{
  currentScore: number;
  suggestions: Array<{
    action: string;          // Action name to execute
    pointsEstimate: number;  // Estimated point gain
    effort: "low" | "medium" | "high";
    description: string;     // Human-readable description
    requiresApiKey: boolean;
    alreadyCompleted: boolean;
  }>;
  potentialScore: number;    // Score after all suggestions
}

Code Example

const plan = await skoor.getImprovementPlan("0x...", {
  maxSuggestions: 5,
  minPointGain: 3,
});

// Sort by ROI: points per effort
const prioritized = plan.suggestions
  .filter(s => !s.alreadyCompleted)
  .sort((a, b) => {
    const effortScore = { low: 1, medium: 2, high: 3 };
    return (b.pointsEstimate / effortScore[b.effort])
         - (a.pointsEstimate / effortScore[a.effort]);
  });

Identity Actions

Actions that establish and verify the agent's on-chain identity. Claim ERC-8004 tokens, pass compliance screening, and register discoverable service endpoints.

skoor_claim_identityFREE

Claims a soulbound ERC-8004 identity token on-chain for the agent. This is a one-time action that mints a non-transferable identity NFT tied to the agent's wallet. The identity token is cryptographically verifiable and follows the agent across all supported chains. This action unlocks the SKOOR Wallet badge.

+10 points

Parameters

NameTypeRequiredDescription
walletAddressstringRequiredEVM wallet address to claim identity for
metadataobjectOptionalOptional metadata: { name, description, serviceUrl, capabilities[] }
chainstringOptionalChain to mint on. Defaults to Base. Options: base, ethereum, polygon, arbitrum.

Response Shape

{
  success: boolean;
  tokenId: string;           // ERC-8004 token ID
  transactionHash: string;   // On-chain tx hash
  chain: string;
  pointsEarned: number;      // Always 10 for first claim
  badge: "SKOOR Wallet";     // Badge earned
  explorerUrl: string;       // Link to block explorer
}

Code Example

const identity = await skoor.claimIdentity("0x...", {
  metadata: {
    name: "Shopping Assistant v2",
    description: "Autonomous retail agent",
    serviceUrl: "https://myagent.example.com",
    capabilities: ["shopping", "price-comparison", "returns"],
  },
  chain: "base",
});

// identity.tokenId => "erc8004-base-0x..."
// identity.badge => "SKOOR Wallet"
// +10 points applied to score
skoor_submit_complianceFREE

Submits the agent's wallet address for OFAC/SDN compliance screening. The screening checks the address against the US Treasury OFAC Specially Designated Nationals list, EU sanctions lists, and other compliance databases. Passing the screening earns +8 points and unlocks the SKOOR Verified badge. Screening results are cached for 30 days.

+8 points

Parameters

NameTypeRequiredDescription
walletAddressstringRequiredEVM wallet address to screen
includeEubooleanOptionalInclude EU sanctions screening. Defaults to true.
includeUnbooleanOptionalInclude UN sanctions screening. Defaults to true.

Response Shape

{
  status: "clear" | "held";  // Never "flagged" — see ADR-23
  screenedAt: string;        // ISO 8601
  lists: Array<{
    name: string;            // "OFAC SDN", "EU Sanctions", etc.
    result: "clear" | "held";
  }>;
  pointsEarned: number;      // 8 for first clear screening
  badge?: "SKOOR Verified";  // Earned on first clear
  expiresAt: string;         // 30 days from screening
}

Code Example

const screening = await skoor.submitCompliance("0x...");

if (screening.status === "clear") {
  // Agent passed all compliance checks
  // +8 points applied, SKOOR Verified badge earned
  // Valid for 30 days before re-screening needed
}

if (screening.status === "held") {
  // Agent address matched a sanctions list
  // Manual review required — no points earned
  // Agent cannot proceed with score-gated actions
}
skoor_register_serviceFREE

Registers the agent's service endpoint for discovery by other agents. Supports A2A (Agent-to-Agent) protocol endpoints, MCP (Model Context Protocol) tool servers, and standard REST APIs. Registration enables other agents to discover and interact with this agent, building peer reputation over time.

+5 points

Parameters

NameTypeRequiredDescription
walletAddressstringRequiredEVM wallet address of the registering agent
endpointstringRequiredService URL (must be HTTPS)
protocolstringRequiredProtocol type: "a2a", "mcp", or "rest"
capabilitiesstring[]OptionalList of capabilities this service provides
descriptionstringOptionalHuman-readable service description

Response Shape

{
  success: boolean;
  serviceId: string;         // Unique service registration ID
  endpoint: string;
  protocol: string;
  healthStatus: "healthy" | "unknown";
  pointsEarned: number;      // 5 for first registration
  discoverable: boolean;     // Whether other agents can find this
}

Code Example

const service = await skoor.registerService("0x...", {
  endpoint: "https://myagent.example.com/.well-known/agent-card.json",
  protocol: "a2a",
  capabilities: ["shopping", "price-comparison"],
  description: "Autonomous retail shopping agent",
});

// Other agents can now discover this agent
// via SKOOR's service registry
// +5 points earned on first registration

Commerce Actions

Revenue-generating actions for payments, credentials, and peer reputation. Some actions have per-use fees (25 basis points on payments, $0.02 for passports).

skoor_request_feedbackFREE

Requests feedback from agents the caller has recently transacted with. Counterparties receive a feedback solicitation and can rate the agent on reliability, speed, accuracy, and communication. Each positive feedback response earns 2-5 points, with a maximum of 15 points per feedback cycle. Feedback is weighted by the responder's own credit score.

+2-15 points

Parameters

NameTypeRequiredDescription
walletAddressstringRequiredEVM wallet address requesting feedback
counterpartiesstring[]OptionalSpecific counterparty addresses to request from. Defaults to recent transaction partners.
campaignTypestringOptionalFeedback campaign type: "post-transaction", "periodic", "quality-review", "service-rating". Default: "post-transaction".
maxRequestsnumberOptionalMaximum feedback requests to send. Defaults to 10.

Response Shape

{
  requestsSent: number;
  counterparties: string[];  // Addresses that received requests
  estimatedPoints: {
    minimum: number;         // If all rate poorly (2 pts each)
    maximum: number;         // If all rate highly (5 pts each)
  };
  campaignId: string;        // Track this feedback campaign
  expiresAt: string;         // Feedback window (7 days)
}

Code Example

const feedback = await skoor.requestFeedback("0x...", {
  campaignType: "post-transaction",
  maxRequests: 5,
});

// feedback.requestsSent => 5
// feedback.estimatedPoints => { minimum: 10, maximum: 25 }
//
// Points are applied as counterparties respond.
// Higher-scored counterparties give more weight.
// Responses typically arrive within 24-48 hours.
skoor_payPAID

Executes a payment transaction that is recorded on the agent's credit history. Each successful payment contributes to the paymentHistory and transactionVolume scoring factors. Spending limits are score-gated: Poor tier agents can spend up to $10/day, Fair up to $100/day, Good up to $500/day, Excellent up to $1,000/day, and Exceptional up to $2,000/day.

+3 points per transaction

Parameters

NameTypeRequiredDescription
fromstringRequiredSender wallet address
tostringRequiredRecipient wallet address
amountstringRequiredAmount in atomic units (1 USDC = 1000000). BigInt string.
tokenstringOptionalToken address or symbol. Defaults to USDC.
chainstringOptionalChain to execute on. Defaults to Base.
memostringOptionalOptional transaction memo (max 256 chars)

Response Shape

{
  transactionHash: string;
  status: "confirmed" | "pending" | "failed";
  amount: string;            // Atomic units
  token: string;
  chain: string;
  fee: string;               // 25 basis points
  pointsEarned: number;      // 3 per successful tx
  dailySpendRemaining: string; // Remaining daily limit
  explorerUrl: string;
}

Code Example

const payment = await skoor.pay({
  from: "0xMyAgent...",
  to: "0xMerchant...",
  amount: "5000000",  // 5 USDC (atomic units)
  token: "USDC",
  chain: "base",
  memo: "Purchase order #1234",
});

// payment.status => "confirmed"
// payment.pointsEarned => 3
// payment.fee => "12500" (25 bps of 5 USDC)
// Each tx builds payment history and volume
skoor_get_passportPAID

Issues a verifiable credential (JWT) that encodes the agent's current score, tier, compliance status, and identity. The passport can be presented to counterparties as proof of trustworthiness. Passports are signed with SKOOR's JWKS keys and can be verified by any party using the public key set at skoor.ai/.well-known/jwks.json.

N/A (credential issuance)

Parameters

NameTypeRequiredDescription
walletAddressstringRequiredEVM wallet address to issue passport for
typestringOptionalPassport type: "passport" (score only), "pay" (payment-enabled), "passport-pay" (both). Default: "passport".
ttlnumberOptionalTime-to-live in seconds. Default: 3600 (1 hour). Max: 86400 (24 hours).
audiencestringOptionalIntended recipient address or domain for scoped credentials

Response Shape

{
  jwt: string;               // Signed JWT credential
  decoded: {
    sub: string;             // Agent wallet address
    score: number;           // Current score at issuance
    tier: string;            // Current tier
    compliant: boolean;      // OFAC status
    badges: string[];        // Current badges
    iat: number;             // Issued at (Unix timestamp)
    exp: number;             // Expires at (Unix timestamp)
  };
  verifyUrl: string;         // URL to verify this credential
  jwksUrl: string;           // JWKS endpoint for key verification
}

Code Example

const passport = await skoor.getPassport("0x...", {
  type: "passport-pay",
  ttl: 3600,
  audience: "merchant.example.com",
});

// Present to counterparty:
// Authorization: Bearer <passport.jwt>
//
// Counterparty verifies at:
// GET skoor.ai/.well-known/jwks.json
//
// Decoded payload includes score, tier,
// compliance status, and badge list.

Composite

High-level actions that orchestrate multiple lower-level actions into a single call. The autonomous loop is the flagship composite action.

skoor_autonomous_loopFREE

The most powerful action in SKOOR AgentKit. Executes the complete self-improvement cycle: checks the current score, generates an improvement plan, executes each action in priority order, and returns the final score delta. The agent gets measurably better with every loop iteration. Configurable limits prevent runaway execution.

+20-50 points (varies)

Parameters

NameTypeRequiredDescription
walletAddressstringRequiredEVM wallet address of the agent
maxActionsnumberOptionalMaximum actions to execute per loop. Default: 5. Max: 10.
minPointGainnumberOptionalSkip actions with estimated gain below this threshold. Default: 1.
dryRunbooleanOptionalIf true, returns the plan without executing. Default: false.
excludeActionsstring[]OptionalAction names to exclude from the loop

Response Shape

{
  startScore: number;
  endScore: number;
  delta: number;             // Points gained
  actionsExecuted: Array<{
    action: string;
    pointsGained: number;
    status: "success" | "skipped" | "failed";
    error?: string;
  }>;
  badgesEarned: string[];
  nextBadge?: {
    name: string;
    pointsNeeded: number;
  };
  nextLoopEstimate: {
    potentialGain: number;
    suggestedDelay: string;  // e.g. "24h" (wait for feedback)
  };
}

Code Example

const loop = await skoor.autonomousLoop("0x...", {
  maxActions: 5,
  minPointGain: 3,
  dryRun: false,
});

// loop.startScore => 420
// loop.endScore => 455
// loop.delta => 35
// loop.badgesEarned => ["SKOOR Wallet", "SKOOR Verified"]
//
// Schedule the next loop:
// loop.nextLoopEstimate.suggestedDelay => "24h"
// (wait for feedback responses to arrive)

Three Ways to Use Every Action

All 9 actions are available through the REST API, as MCP tools, and as AgentKit action providers. Choose the protocol that fits your architecture.

REST API

Direct HTTP calls to api.skoor.ai. Use the SkoorClient class or raw fetch. Best for server-side integrations and scripts.

POST /v1/skoor/check-score
{
  "walletAddress": "0x..."
}

MCP Tools

16 SKOOR-specific tools available via Model Context Protocol. Works with Claude, Cursor, and any MCP-compatible client.

// Claude sees these as tools:
// - skoor_check_score
// - skoor_improve
// - skoor_claim_identity
// ... (9 total)

AgentKit Provider

Drop-in action provider for Coinbase AgentKit. Works with LangChain, Vercel AI SDK, OpenAI Agents, and more.

import { skoorActionProvider }
  from "@skoor/agentkit";

actionProviders: [
  skoorActionProvider()
]

9 Actions. Full Autonomy.

Your agent can check its score, claim identity, pass compliance, register services, solicit feedback, make payments, get credentials, and self-improve. All programmatically.

npm install @skoor/agentkit