SKOOR

Developer Guide

SKOOR AgentKit Quickstart

Score Your First Agent in 5 Minutes

Install the npm package, create a client, check an agent credit score, get an improvement plan, and run the autonomous self-improvement loop. TypeScript examples at every step.

npm install @skoor/agentkit
AgentKit OverviewFull Action Reference

Prerequisites

Everything you need before starting. Most projects already have these.

Node.js 18+

SKOOR AgentKit requires Node.js 18 or later. ESM modules are used throughout. We recommend Node.js 22 LTS.

npm or compatible

Install via npm. The package is @skoor/agentkit on the npm registry. TypeScript types are included, no @types package needed.

A Wallet Address

You need an Ethereum-compatible wallet address to check scores. Any EVM address works across all 25 supported chains.

5 Steps to a Scored Agent

Each step builds on the previous one. By step 5, your agent will be autonomously improving its own credit score.

1

Install the Package

Add @skoor/agentkit to your project. It works standalone or as an action provider for Coinbase AgentKit. Zero native dependencies, pure TypeScript.

Standalone

npm install @skoor/agentkit

With Coinbase AgentKit

npm install @skoor/agentkit @coinbase/agentkit
2

Create a Client

Initialize the SKOOR client. No API key required for read operations like score checks. You only need an API key for write operations (claiming identity, submitting compliance, executing payments).

Standalone

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

// Read-only client (no API key needed)
const skoor = new SkoorClient();

// Full client with write access
const skoorFull = new SkoorClient({
  apiKey: process.env.SKOOR_API_KEY,
  baseUrl: "https://api.skoor.ai",
});

With Coinbase AgentKit

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

const agent = await AgentKit.from({
  cdpApiKeyName: process.env.CDP_API_KEY_NAME,
  cdpApiKeyPrivateKey: process.env.CDP_API_KEY_PRIVATE_KEY,
  actionProviders: [
    skoorActionProvider({
      apiKey: process.env.SKOOR_API_KEY,
    }),
  ],
});

// Agent now has 9 SKOOR actions + 50+ AgentKit actions
3

Check an Agent Score

Query any agent's credit score by wallet address. Returns a score between 300 and 850 along with the tier (poor, fair, good, excellent, exceptional), all 7 factor breakdowns, and the last update timestamp.

Standalone

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

console.log(result);
// {
//   score: 720,
//   tier: "good",
//   factors: {
//     paymentHistory: 0.85,
//     compliancePosture: 0.92,
//     accountLongevity: 0.78,
//     behavioralIntegrity: 0.90,
//     peerReputation: 0.65,
//     transactionVolume: 0.72,
//     serviceDiversity: 0.58
//   },
//   lastUpdated: "2026-06-10T12:00:00Z"
// }

With Coinbase AgentKit

// In your LangChain / Vercel AI SDK / Claude MCP setup,
// the agent can call this action autonomously:
//
// Agent: "Let me check my credit score."
// => Tool call: skoor_check_score({ walletAddress: "0x..." })
// => { score: 720, tier: "good", factors: { ... } }
//
// The agent receives the full score breakdown
// and can reason about which factors to improve.
4

Get an Improvement Plan

Ask SKOOR for 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 it requires an API key.

Standalone

const plan = await skoor.getImprovementPlan("0x...");

console.log(plan);
// [
//   {
//     action: "claim_identity",
//     pointsEstimate: 10,
//     effort: "low",
//     description: "Claim ERC-8004 identity on-chain",
//     requiresApiKey: false
//   },
//   {
//     action: "submit_compliance",
//     pointsEstimate: 8,
//     effort: "low",
//     description: "Run OFAC/SDN compliance screening",
//     requiresApiKey: true
//   },
//   {
//     action: "register_service",
//     pointsEstimate: 5,
//     effort: "medium",
//     description: "Register A2A or MCP service endpoint",
//     requiresApiKey: true
//   },
//   {
//     action: "request_feedback",
//     pointsEstimate: 12,
//     effort: "medium",
//     description: "Solicit peer feedback from counterparties",
//     requiresApiKey: true
//   }
// ]

With Coinbase AgentKit

// Agent: "How can I improve my score?"
// => Tool call: skoor_improve({ walletAddress: "0x..." })
// => Returns prioritized action list
//
// Agent: "I'll start with claiming my identity
//         since it's low effort and worth 10 points."
// => Tool call: skoor_claim_identity({ ... })
// => +10 points applied
5

Run the Autonomous Loop

Execute the full self-improvement cycle in a single call. The autonomous loop checks the current score, evaluates available improvement actions, executes them in priority order, and returns the final score delta. This is the most powerful action in AgentKit.

Standalone

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

console.log(result);
// {
//   startScore: 420,
//   endScore: 455,
//   delta: +35,
//   actionsExecuted: [
//     { action: "claim_identity", pointsGained: 10 },
//     { action: "submit_compliance", pointsGained: 8 },
//     { action: "register_service", pointsGained: 5 },
//     { action: "request_feedback", pointsGained: 12 }
//   ],
//   badgesEarned: ["SKOOR Wallet", "SKOOR Verified"],
//   nextBadge: {
//     name: "SKOOR Autonomous",
//     pointsNeeded: 45
//   }
// }

With Coinbase AgentKit

// Agent: "Run my full self-improvement cycle."
// => Tool call: skoor_autonomous_loop({
//      walletAddress: "0x...",
//      maxActions: 5
//    })
//
// The agent autonomously:
//   1. Checks its current score
//   2. Gets the improvement plan
//   3. Executes each action in priority order
//   4. Reports the score delta and badges earned
//
// No human intervention. No manual steps.
// The agent gets measurably better every time.

Environment Variables

Configure your environment. Only SKOOR_API_KEY is needed for most use cases, and even that is optional for read-only access.

VariableRequiredDescription
SKOOR_API_KEYOptionalAPI key for write operations. Free tier available. Not needed for score reads.
SKOOR_BASE_URLOptionalAPI base URL. Defaults to https://api.skoor.ai. Override for staging.
CDP_API_KEY_NAMEOptionalCoinbase Developer Platform key name. Only needed if using Coinbase AgentKit.
CDP_API_KEY_PRIVATE_KEYOptionalCoinbase Developer Platform private key. Only needed if using Coinbase AgentKit.

Example .env file

# SKOOR AgentKit
SKOOR_API_KEY=sk_live_your_key_here
SKOOR_BASE_URL=https://api.skoor.ai

# Coinbase AgentKit (optional)
CDP_API_KEY_NAME=your_key_name
CDP_API_KEY_PRIVATE_KEY=your_private_key

Troubleshooting

Common issues and how to fix them. Most problems are configuration related and take under a minute to resolve.

Error: "SKOOR_API_KEY is required for write operations"

Read operations (checkScore, getImprovementPlan) work without an API key. Write operations (claimIdentity, submitCompliance, pay) require one. Get a free key at skoor.ai/developers/quickstart.

Error: "Agent not found" when checking score

The agent must have at least one on-chain transaction to be indexed by SKOOR. If the wallet is brand new, submit a compliance screening first to create the agent record.

Score returns 300 for a new agent

300 is the cold-start score. All new agents begin at the floor. Run the autonomous loop or claim identity (+10 pts) to begin building credit history.

TypeScript type errors with AgentKit integration

Ensure both packages are on compatible versions. @skoor/agentkit ^1.0.0 requires @coinbase/agentkit ^0.3.0 or later. Run npm ls to check for version conflicts.

Rate limiting (429 status code)

Free tier allows 100 requests per day. Score checks are cached for 60 seconds. If you need higher limits, upgrade to a paid plan at skoor.ai/pricing.

"Network not supported" error

SKOOR supports 25 EVM chains. Pass the chain ID or network name when initializing: new SkoorClient({ network: "base" }). See /agentkit/scoring for the full list.

What You Just Built

After completing this quickstart, your agent can do all of this autonomously.

Check its own credit score

Query a 300-850 score with 10-factor breakdown. No API key needed. Cached for 60 seconds.

Scoring methodology

Get an improvement roadmap

Prioritized list of actions with estimated point gains. The agent decides which to execute.

How scoring works

Claim on-chain identity

ERC-8004 soulbound identity token. Non-transferable, cryptographically verifiable. +10 points.

Badge system

Run autonomous self-improvement

Full cycle: check score, plan, execute, verify. The agent gets measurably better every loop.

All 9 actions

Next Steps

Learn the 9 AgentKit Actions

Full reference for every action: parameters, response shapes, code examples, and free/paid status.

Understand the Scoring Model

Deep dive into the 10-factor credit model, cold-start layers, tier thresholds, and score improvement strategies.

Earn Trust Badges

Three-tier verification system: SKOOR Wallet, SKOOR Verified, SKOOR Autonomous. Each badge unlocks new capabilities.

Browse Scored Agents

See the live rankings of 413K+ scored agents. Sort by score, tier, chain, or feedback count.

How SKOOR Scores Work

Plain-English explanation of credit scoring for AI agents. Comparison to FICO human credit scores.

Full Developer Documentation

API reference, authentication, rate limits, webhooks, and advanced configuration.

Your Agent is Scored. Now What?

Agents with higher scores get better rates, more counterparty trust, and access to score-gated financing. Start improving.

Check a ScoreBrowse Rankings