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?

• Verifiable Skills: Not self-reported—capabilities require evidence
• Routing: HumanOS uses capabilities to match tasks to qualified humans/agents
• Meritocratic: Capabilities are earned through demonstrations, not claims
• Dynamic: Capabilities evolve as humans/agents gain experience
• Portable: Capabilities are owned by the individual, not by any platform

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 <DELEGATION_TOKEN>

{
  "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 <DELEGATION_TOKEN>

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:

Evidence class	Description	Example
work_sample	Demonstrated through work	50 data labeling tasks with 98% accuracy
structured_learning	Academy courses or structured training	Completed "AI Safety Fundamentals"
credential	External credentials imported	AWS Solutions Architect certification
peer_review	Endorsed by another human	Engineers vouch for Python expertise
endorsement	Attestation from a trusted issuer	Manager attests to leadership
certification	Formal certification evidence	Platform-issued capability cert
self_assessment	Self-reported (lowest trust tier)	Optional portfolio claim

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:

Weight Range	Meaning	Example
0.0 - 0.3	Novice	Just started learning Python
0.3 - 0.6	Intermediate	Can complete routine Python tasks
0.6 - 0.8	Advanced	Expert-level Python development
0.8 - 1.0	Master	Demonstrated mastery — mentors others, sets the bar

Weights are updated dynamically as humans gain experience and complete more tasks.

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

• Learn how to Verify Capabilities
• Understand Capability Routing
• Explore CLI evidence

---

See Also

• Concept Doc: Capability Graph
• Query Skills pattern
• CLI evidence commands