Introduction to Paradigm SDK

Paradigm SDK is a compressed narrative identity platform that enables users to build and own structured representations of who they are - their experiences, beliefs, connections, and aspirations.

What is Paradigm?

Paradigm is a platform where:

Users construct compressed identity graphs from their life narratives
AI Agents collaborate to extract, structure, and validate identity data
Identity flows are traced, auditable, and agent-attributed

Think of it as a structured identity vault with full multi-agent support. Users store their experiences, beliefs, entities they connect to, and goals in a semantic graph. Multiple AI agents can collaborate on extraction and enhancement, with complete traceability of who contributed what.

Core Philosophy

1. Compressed Narrative Identity

Your identity isn't everything about you - it's the compressed structure of who you are:

EXPERIENCES: Things that happened and shaped you
BELIEFS: What you think is true
ENTITIES: Who/what you connect to
GOALS: What you're trying to achieve

2. Three Meaning Levels

Not all information is equally important to your identity:

IDENTITY: Story-constitutive (can't explain yourself without it)
CONTEXT: Useful background (helps understand but not defining)
DATA: Just facts (true but not narratively significant)

3. Multi-Agent Collaboration with Traceability

Multiple AI agents can work together on identity construction:

Extraction agents parse narratives
Enhancement agents add context
QA agents validate quality
Every contribution is tracked with full agent metadata

4. Full Transparency

Every change is audited. Users can see:

Which agents modified their data
What changes were made
When changes occurred
Confidence scores for each contribution

How It Works

┌─────────────────────────────────────────────────────────────────┐
│                    IDENTITY GRAPH (User's Vault)                 │
│                                                                  │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐         │
│   │ EXPERIENCES  │  │   BELIEFS    │  │   ENTITIES   │         │
│   │ (formative)  │  │ (worldview)  │  │  (connects)  │         │
│   └──────────────┘  └──────────────┘  └──────────────┘         │
│                                                                  │
│   ┌──────────────────────────────────────────────────────┐     │
│   │                      GOALS                            │     │
│   │                  (aspirations)                        │     │
│   └──────────────────────────────────────────────────────┘     │
│                                                                  │
│   Each node: 3 meaning levels (IDENTITY → CONTEXT → DATA)       │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘
                              ▲
                              │ Multi-agent collaboration
                              │ (with full traceability)
┌─────────────────────────────────────────────────────────────────┐
│                         AI AGENT LAYER                           │
│                                                                  │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐         │
│   │  Extraction  │  │ Enhancement  │  │   Quality    │         │
│   │    Agent     │  │    Agent     │  │  Assurance   │         │
│   └──────────────┘  └──────────────┘  └──────────────┘         │
│                                                                  │
│   Node Ledger: Tracks all agent contributions                   │
│   Node History: Complete version tracking                       │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Key Concepts

Concept	Description
Node	A semantic unit: EXPERIENCE, BELIEF, ENTITY, or GOAL
Meaning Level	Narrative depth: IDENTITY, CONTEXT, or DATA
Relationship	Typed connections (shaped, supports, conflicts, evidenced_by)
Agent Metadata	Information about which AI agent modified data
Node Ledger	Complete record of all agents that contributed
Node History	Version-by-version evolution of nodes

The Four Node Types

EXPERIENCE: Things That Happened

Decision Test: Can you answer "When did this happen?"

{
  "title": "First day teaching my own class",
  "node_type": "EXPERIENCE",
  "meaning_level": "IDENTITY",
  "metadata": {
    "properties": {
      "when": {"type": "instance", "status": "done", "start": "2020-09-15"},
      "where": "University lecture hall",
      "significance": "Moment I knew teaching was my calling"
    }
  }
}

BELIEF: What You Think Is True

Decision Test: Can you put "I believe..." in front?

{
  "title": "Education expands possible futures",
  "node_type": "BELIEF",
  "meaning_level": "IDENTITY",
  "metadata": {
    "properties": {
      "category": "about_world",
      "strength_of_belief": 9
    }
  }
}

ENTITY: Who/What You Connect To

Decision Test: Can you point to something external?

{
  "title": "Dr. Sarah Chen - my PhD advisor",
  "node_type": "ENTITY",
  "meaning_level": "IDENTITY",
  "metadata": {
    "properties": {
      "name": "Dr. Sarah Chen",
      "category": "person"
    }
  }
}

GOAL: What You're Trying to Achieve

Decision Test: Are you working toward this?

{
  "title": "Build educational platform for underserved communities",
  "node_type": "GOAL",
  "meaning_level": "IDENTITY",
  "metadata": {
    "properties": {
      "motivation": "Expand educational access",
      "time_horizon": "lifelong",
      "status": "active"
    }
  }
}

Multi-Agent Infrastructure

Agent Metadata

Every node tracks which agent last modified it:

{
  "agent_metadata": {
    "agent_id": "0c59fea4-fe7e-41af-a246-e3eb1819be13",
    "agent_name": "Memory Extraction Agent v2.1",
    "agent_type": "experience_extractor",
    "confidence_score": 0.92,
    "processing_time_ms": 1850,
    "source_models": ["gpt-4"],
    "validation_status": "verified"
  },
  "last_modified_by_agent_id": "0c59fea4-fe7e-41af-a246-e3eb1819be13"
}

Node Ledger

Track all agents that contributed to a node:

ledger = client.nodes.get_ledger(node_id="node_abc")

# Returns:
{
  "total_agents": 3,
  "agents": [
    {"agent_name": "Extraction Agent", "contribution_count": 1},
    {"agent_name": "Enhancement Agent", "contribution_count": 2},
    {"agent_name": "QA Agent", "contribution_count": 1}
  ]
}

Node History

Complete version tracking with agent attribution:

history = client.nodes.get_history(node_id="node_abc")

# Each version shows:
# - What changed
# - Which agent made the change
# - Confidence score at that time
# - Full snapshot of node state

For Developers

As a developer, you can:

Build AI agents that extract and structure identity data
Collaborate with other agents on the same nodes
Track contributions through the node ledger
Validate quality with confidence scoring
Audit changes through complete history

Quick Example: Multi-Agent Collaboration

from paradigm import ParadigmClient

client = ParadigmClient(api_key="your-api-key")

# Agent 1: Extract experience
node = client.nodes.create(
    title="First day teaching",
    node_type="EXPERIENCE",
    meaning_level="CONTEXT",
    agent_metadata={
        "agent_id": "agent_001",
        "agent_name": "Extraction Agent",
        "confidence_score": 0.75
    },
    last_modified_by_agent_id="agent_001"
)

# Agent 2: Enhance with significance
client.nodes.update(
    node_id=node['id'],
    meaning_level="IDENTITY",
    metadata={
        "properties": {
            "significance": "Realized my calling"
        }
    },
    agent_metadata={
        "agent_id": "agent_002",
        "agent_name": "Enhancement Agent",
        "confidence_score": 0.88
    },
    last_modified_by_agent_id="agent_002"
)

# Agent 3: Validate
client.nodes.update(
    node_id=node['id'],
    agent_metadata={
        "agent_id": "agent_003",
        "agent_name": "QA Agent",
        "confidence_score": 0.95,
        "validation_status": "verified"
    },
    last_modified_by_agent_id="agent_003"
)

# View all contributors
ledger = client.nodes.get_ledger(node['id'])
print(f"Total agents: {ledger['total_agents']}")  # 3

Key Features

🎯 Structured Identity

Four semantic node types (EXPERIENCE, BELIEF, ENTITY, GOAL) with type-specific properties.

📊 Three Meaning Levels

Distinguish between story-constitutive (IDENTITY), useful context (CONTEXT), and mere facts (DATA).

🤖 Multi-Agent Support

Multiple AI agents can collaborate with full traceability and confidence scoring.

📜 Complete History

Every change tracked with version numbers, timestamps, and agent attribution.

🔍 Node Ledger

See all agents that contributed to a node and how many edits each made.

✅ Quality Tracking

Confidence scores and validation status for every agent contribution.

Next Steps

🎓 Node Types Guide

Learn about EXPERIENCE, BELIEF, ENTITY, and GOAL nodes.

Learn Node Types →

🤖 Agent Infrastructure

Build multi-agent systems with full traceability.

Build Agents →

🚀 API Reference

Complete API documentation with examples.

View API Docs →

🔗 Relationships

Connect nodes with typed relationships.

Learn Relationships →

SDKs

We provide official SDKs for:

Python: pip install paradigm-sdk
JavaScript/TypeScript: npm install @paradigm/sdk

Both SDKs provide full API coverage with type hints, IDE autocomplete, and agent metadata support.

Design Principles

Compression Over Completeness

Not everything belongs in your identity graph - only what's narratively significant.

Semantic Structure

Use the four node types correctly - they're not arbitrary categories, they're semantic distinctions.

Meaning Levels Matter

IDENTITY nodes are what you can't explain yourself without. Be selective.

Agent Transparency

Always track agent metadata - users should know which AI contributed what.

Nodes can evolve: start as CONTEXT, elevate to IDENTITY when significance becomes clear.

What is Paradigm?​

Core Philosophy​

1. Compressed Narrative Identity​

2. Three Meaning Levels​

3. Multi-Agent Collaboration with Traceability​

4. Full Transparency​

How It Works​

Key Concepts​

The Four Node Types​

EXPERIENCE: Things That Happened​

BELIEF: What You Think Is True​

ENTITY: Who/What You Connect To​

GOAL: What You're Trying to Achieve​

Multi-Agent Infrastructure​

Agent Metadata​

Node Ledger​

Node History​

For Developers​

Quick Example: Multi-Agent Collaboration​

Key Features​

🎯 Structured Identity​

📊 Three Meaning Levels​

🤖 Multi-Agent Support​

📜 Complete History​

🔍 Node Ledger​

✅ Quality Tracking​

Next Steps​