Grant Capability

Overview

Award a verified skill or capability to a human or agent based on demonstrated evidence. Every capability grant is cryptographically signed, provenance-tracked, and backed by evidence—making it verifiable and unforgeable.

Why Grant Capabilities?

Think of it like: Earning a certification, but it's backed by real work you've done, cryptographically verified, and follows you everywhere.

SDK Examples

REST API Example

Capabilities are not self-asserted. Ingest evidence first, then check eligibility:

POST /v1/evidence
Content-Type: application/json
Authorization: Bearer 
{
  "passport_did": "did:human:alice-smith",
  "evidence_class": "work_sample",
  "tier": "B",
  "title": "AI safety evaluation streak",
  "description": "Successfully completed 15 AI safety evaluations with 95% accuracy",
  "issuer_did": "did:human:supervisor-bob",
  "metadata": {
    "tasks_completed": 15,
    "accuracy_rate": 0.95
  }
}

GET /v1/evidence/eligibility?passport_did=did:human:alice-smith
Authorization: Bearer 

Eligibility response (200 OK):

{
  "passport_did": "did:human:alice-smith",
  "eligible_capability_ids": ["cap.ai_safety_evaluation"],
  "computed_at": "2026-01-10T12:00:00Z",
  "snapshot_version": 1
}

Types of Evidence

LCEF evidence classes used by client.evidence.ingest:

Use Cases

1. Evidence after training

Scenario: Academy (or any trainer) completes a course — ingest structured_learning evidence, then check eligibility.

import { HumanClient } from '@human/sdk';
async function onAcademyCourseComplete(
  client: HumanClient,
  studentDid: string,
  course: { id: string; name: string; finalScore: number },
) {
  if (course.finalScore < 70) {
    throw new Error('Course not passed');
  }
  const { evidence } = await client.evidence.ingest({
    passport_did: studentDid,
    evidence_class: 'structured_learning',
    tier: 'B',
    title: course.name,
    description: Completed ${course.name} with score ${course.finalScore}%,
    issuer_did: 'did:human:academy-system',
    metadata: { course_id: course.id, final_score: course.finalScore },
  });
  const eligibility = await client.evidence.getEligibility(studentDid);
  console.log(Evidence ${evidence.id}; eligible: ${eligibility.eligible_capability_ids.join(', ') || '(none yet)'});
  return { evidence, eligibility };
}

2. Evidence after task completion

Scenario: Workforce task outcomes become work_sample evidence that feeds eligibility.

async function recordTaskEvidence(
  client: HumanClient,
  humanDid: string,
  task: { id: string; type: string; requiredCapability: string },
  performance: { accuracy: number; efficiency: number; quality: number },
) {
  const score =
    performance.accuracy * 0.5 +
    performance.efficiency * 0.3 +
    performance.quality * 0.2;
  const { evidence } = await client.evidence.ingest({
    passport_did: humanDid,
    evidence_class: 'work_sample',
    tier: score >= 0.85 ? 'A' : 'B',
    title: ${task.type} completion,
    description: Completed ${task.type} with ${(score * 100).toFixed(0)}% composite performance,
    issuer_did: 'did:org:workforce',
    metadata: {
      task_id: task.id,
      required_capability: task.requiredCapability,
      performance,
    },
  });
  return client.evidence.getEligibility(humanDid).then((eligibility) => ({
    evidence,
    eligibility,
  }));
}

3. Import external credential

Scenario: Verified external credential becomes LCEF credential evidence.

async function importExternalCredential(
  client: HumanClient,
  humanDid: string,
  verified: {
    credentialName: string;
    capabilityHint: string;
    issuer: string;
    issueDate: string;
    verificationUrl: string;
  },
) {
  const { evidence } = await client.evidence.ingest({
    passport_did: humanDid,
    evidence_class: 'credential',
    tier: 'A',
    title: verified.credentialName,
    description: Verified external credential: ${verified.credentialName},
    issuer_did: verified.issuer,
    issued_at: verified.issueDate,
    metadata: {
      capability_hint: verified.capabilityHint,
      verification_url: verified.verificationUrl,
    },
  });
  const eligibility = await client.evidence.getEligibility(humanDid);
  console.log(Imported credential evidence ${evidence.id});
  return { evidence, eligibility };
}

Capability Weights

Capability weights range from 0.0 to 1.0, representing confidence/proficiency:

Provenance

Every capability grant is permanently recorded:

{
  "eventType": "evidence_ingested",
  "passport_did": "did:human:alice-smith",
  "evidence_class": "work_sample",
  "tier": "B",
  "issuer_did": "did:human:supervisor-bob",
  "ledger_anchor_ref": "att_7b3f9a2c",
  "timestamp": "2026-01-10T12:00:00Z"
}

This creates an immutable capability history that can be verified by anyone.

Next Steps

---

See Also