A human life involves identity, temporal context, relationships, domains, projects, resources, and state — all evolving over time. This schema captures that structure.
PCF organizes human context into five conceptual layers, from stable identity at the core to ephemeral current state at the edge.
The most stable layer. Changes slowly over years.
The narrative arc of your life. Past, present trajectory, future.
The major areas of life, each with its own subgraph.
What's happening right now. High churn, high relevance.
Patterns about patterns. Self-knowledge and self-awareness.
Entities are the nodes in your context graph. PCF defines a core vocabulary that all implementations should understand.
Goal A desired outcome with optional deadline, priority, and parent goal. Goals nest hierarchically and can conflict.
supports conflicts_with depends_on Project A bounded effort toward a goal. Has a state (active/paused/complete/abandoned), timeline, and deliverables.
part_of blocks depends_on Task A discrete action item. The leaf nodes of the goal/project hierarchy. Has state, due date, context requirements.
part_of depends_on blocked_by Person Someone in your social graph. Has connection strength, context, history, and relationship type.
related_to part_of (organization)
Organization A group you're part of or interact with. Company, team, community, family unit.
contains related_to Value Something you care about. Has weight and can conflict with other values. Forms the basis of decision-making patterns.
supports conflicts_with Event Something that happened. Has temporal bounds, participants, outcomes, and emotional valence.
caused_by leads_to Skill A capability you have. Has proficiency level, recency of use, and acquisition history.
supports part_of (domain)
Resource Something you have or need. Time, money, energy, attention, social capital.
supports blocks depends_on State A point-in-time snapshot. Emotional state, energy level, focus area, environmental context.
caused_by leads_to
Implementations can define additional entity types. Use the type
field with a namespaced identifier: helaix:custom_type.
Unknown types should be preserved during sync.
Relations are the edges in your context graph. They capture how entities connect, influence, and depend on each other.
| Relation | Semantics | Inverse | Example |
|---|---|---|---|
supports | A helps achieve B | supported_by | Project → Goal |
conflicts_with | A and B cannot both be true/achieved | conflicts_with | Value ↔ Value |
depends_on | A requires B to proceed | depended_by | Task → Task |
blocks | A prevents B from progressing | blocked_by | Resource → Project |
part_of | A is contained within B | contains | Task → Project |
contains | A contains B as a component | part_of | Project → Task |
caused_by | A resulted from B | leads_to | State → Event |
leads_to | A resulted in B | caused_by | Event → State |
related_to | A and B are connected (weak/untyped) | related_to | Person ↔ Person |
Every relation carries additional metadata:
weight: float Strength of the relationship (0.0 - 1.0). Optional, defaults to 1.0.
temporal_bounds: [start, end?] When this relationship is valid. Null end means still active.
confidence: float How certain we are about this relationship (0.0 - 1.0).
source: string Where this relationship came from. "user", "inference", "import".
The minimal core schema that all PCF implementations must understand. Designed to be stable, simple, and extensible.
Entity The base type for all context records Entity {
id: uuid // Stable identifier
type: EntityType // Goal, Project, Task, etc.
created: timestamp // When first recorded
modified: timestamp // Last modification
valid_from: timestamp // When true in reality
valid_to: timestamp? // When ceased being true (null = current)
confidence: float // 0.0 - 1.0
source: string // "user" | "inference" | "import:origin"
data: type-specific-payload // Varies by EntityType
}Relation Connects entities in the graph Relation {
id: uuid // Stable identifier
from: entity_id // Source entity
to: entity_id // Target entity
type: RelationType // supports, depends_on, etc.
weight: float // 0.0 - 1.0, default 1.0
temporal_bounds: [start, end?]
confidence: float // 0.0 - 1.0
source: string
metadata: {} // Extensible attributes
}Goal Example entity type payload Goal.data {
title: string
description: string?
deadline: timestamp?
priority: "critical" | "high" | "medium" | "low"
status: "active" | "achieved" | "abandoned" | "blocked"
parent_goal_id: uuid? // For hierarchical goals
domain: string // "career" | "health" | "finance" | ...
success_criteria: string[] // How do we know it's done?
}PCF is designed to be extended without breaking compatibility. The schema registry pattern enables gradual evolution.
Use namespaced type identifiers. Unknown types should be preserved during sync operations.
type: "helaix:habit_tracker" type: "myapp:custom_entity" Same namespacing pattern. Include inverse relation name for bidirectional queries.
type: "helaix:inspired_by" inverse: "helaix:inspired" Type-specific data can include additional fields. Use the metadata object for truly unstructured extensions.
data.custom_field: "value" metadata.app_specific: { ... }