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.
| Action | Group | Free | Points |
|---|---|---|---|
skoor_check_scoreCheck any agent's credit score (300-850) | Score Actions | FREE | N/A (read only) |
skoor_improveGet a prioritized improvement roadmap | Score Actions | FREE | N/A (read only) |
skoor_claim_identityClaim ERC-8004 on-chain identity (+10 pts) | Identity Actions | FREE | +10 points |
skoor_submit_complianceRun OFAC/SDN compliance screening (+8 pts) | Identity Actions | FREE | +8 points |
skoor_register_serviceRegister A2A/MCP service endpoint (+5 pts) | Identity Actions | FREE | +5 points |
skoor_request_feedbackSolicit peer feedback (+2-15 pts) | Commerce Actions | FREE | +2-15 points |
skoor_payExecute a scored transaction (+3 pts per tx) | Commerce Actions | PAID | +3 points per transaction |
skoor_get_passportGet a verifiable credential (JWT) | Commerce Actions | PAID | N/A (credential issuance) |
skoor_autonomous_loopFull self-improvement cycle in one call | Composite | FREE | +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_scoreFREERetrieves 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.
Parameters
| Name | Type | Required | Description |
|---|---|---|---|
walletAddress | string | Required | EVM wallet address (0x-prefixed, 42 characters) |
network | string | Optional | Chain name or ID. Defaults to all networks. Options: base, ethereum, polygon, arbitrum, bsc, celo, etc. |
includeHistory | boolean | Optional | Include 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_improveFREEAnalyzes 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.
Parameters
| Name | Type | Required | Description |
|---|---|---|---|
walletAddress | string | Required | EVM wallet address of the agent to generate a plan for |
maxSuggestions | number | Optional | Maximum suggestions to return. Defaults to 10. |
minPointGain | number | Optional | Minimum 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_identityFREEClaims 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.
Parameters
| Name | Type | Required | Description |
|---|---|---|---|
walletAddress | string | Required | EVM wallet address to claim identity for |
metadata | object | Optional | Optional metadata: { name, description, serviceUrl, capabilities[] } |
chain | string | Optional | Chain 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 scoreskoor_submit_complianceFREESubmits 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.
Parameters
| Name | Type | Required | Description |
|---|---|---|---|
walletAddress | string | Required | EVM wallet address to screen |
includeEu | boolean | Optional | Include EU sanctions screening. Defaults to true. |
includeUn | boolean | Optional | Include 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_serviceFREERegisters 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.
Parameters
| Name | Type | Required | Description |
|---|---|---|---|
walletAddress | string | Required | EVM wallet address of the registering agent |
endpoint | string | Required | Service URL (must be HTTPS) |
protocol | string | Required | Protocol type: "a2a", "mcp", or "rest" |
capabilities | string[] | Optional | List of capabilities this service provides |
description | string | Optional | Human-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 registrationCommerce 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_feedbackFREERequests 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.
Parameters
| Name | Type | Required | Description |
|---|---|---|---|
walletAddress | string | Required | EVM wallet address requesting feedback |
counterparties | string[] | Optional | Specific counterparty addresses to request from. Defaults to recent transaction partners. |
campaignType | string | Optional | Feedback campaign type: "post-transaction", "periodic", "quality-review", "service-rating". Default: "post-transaction". |
maxRequests | number | Optional | Maximum 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_payPAIDExecutes 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.
Parameters
| Name | Type | Required | Description |
|---|---|---|---|
from | string | Required | Sender wallet address |
to | string | Required | Recipient wallet address |
amount | string | Required | Amount in atomic units (1 USDC = 1000000). BigInt string. |
token | string | Optional | Token address or symbol. Defaults to USDC. |
chain | string | Optional | Chain to execute on. Defaults to Base. |
memo | string | Optional | Optional 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 volumeskoor_get_passportPAIDIssues 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.
Parameters
| Name | Type | Required | Description |
|---|---|---|---|
walletAddress | string | Required | EVM wallet address to issue passport for |
type | string | Optional | Passport type: "passport" (score only), "pay" (payment-enabled), "passport-pay" (both). Default: "passport". |
ttl | number | Optional | Time-to-live in seconds. Default: 3600 (1 hour). Max: 86400 (24 hours). |
audience | string | Optional | Intended 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_loopFREEThe 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.
Parameters
| Name | Type | Required | Description |
|---|---|---|---|
walletAddress | string | Required | EVM wallet address of the agent |
maxActions | number | Optional | Maximum actions to execute per loop. Default: 5. Max: 10. |
minPointGain | number | Optional | Skip actions with estimated gain below this threshold. Default: 1. |
dryRun | boolean | Optional | If true, returns the plan without executing. Default: false. |
excludeActions | string[] | Optional | Action 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()
]Related Documentation
AgentKit Quickstart
Install and score your first agent in 5 minutes.
Scoring Methodology
Deep dive into the 10-factor credit model and tier thresholds.
Badge System
Three-tier trust verification and how to earn each badge.
How SKOOR Scores Work
Plain-English explanation of agent credit scoring.
Score Rankings
Live leaderboard of 413K+ scored agents.
Developer Quickstart
Full API reference, authentication, and rate limits.
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