Document Purpose: This document provides a comprehensive specification of Cogniscient—the adaptive intelligence substrate that serves as the memory, knowledge graph, and experience layer for the ARCHER Suite. Cogniscient is not a database, not a data lake, not a search engine. Cogniscient is the living semantic spine that enables systems to remember, relate, reason, and evolve.
Created: January 2026
Status: Conceptual Architecture & Implementation Specification
Definition: The Data Processor & Insight Engine for the VTX business platform.
Use "Cognigraph" when discussing:
Definition: The Memory & Experience System for AI-driven characters and agents.
Use "Cogniscient" when discussing:
This document uses "Cogniscient" as the primary term, recognizing that both manifestations share the same architectural foundation.
Cogniscient is the adaptive intelligence substrate—the component that gives AI systems the ability to:
Cogniscient stores experiences, not just facts. It understands relationships, not just data. It enables contextual intelligence, not just retrieval.
This means:
Traditional AI systems suffer from fundamental memory limitations:
Session 1: User tells AI about their project
Session 2: AI has no memory of the project
Session 3: User must re-explain everything
This creates friction, wastes time, and prevents AI from being truly helpful over time.
Cogniscient approaches memory the way humans do:
| Human Memory | Cogniscient Equivalent |
|---|---|
| Remember the gist, not verbatim | Store summaries and key concepts |
| Associate related memories | Link entities through relationships |
| Recall based on relevance | Retrieve based on semantic similarity |
| Memories fade if not reinforced | Importance weighting and decay |
| Context triggers recall | Situation-aware retrieval |
| Memories shape understanding | Accumulated context informs reasoning |
Rather than storing every word of every interaction, Cogniscient stores the gist:
Raw Conversation (1000 tokens):
"So we had this meeting yesterday with the Acme team, and
Sarah from their side was really pushing back on the timeline.
She said Q2 was too aggressive given their internal constraints.
John suggested we could phase the rollout, starting with the
pilot in March and full deployment in Q3. Everyone seemed okay
with that compromise, though Sarah wanted it in writing..."
Cogniscient Gist (100 tokens):
Entity: Meeting (2025-01-25)
Participants: [User, Sarah (Acme), John]
Topic: Project timeline
Key Points:
- Original Q2 timeline challenged
- Acme has internal constraints
- Compromise: Pilot March, Full Q3
Decisions: Phased rollout approach
Follow-ups: Document agreement in writing
Sentiment: Constructive tension → resolution
Links: [Acme Corp, Project X, Q2 Planning]
Benefits:
Cogniscient uses a hybrid architecture combining graph and vector capabilities:
┌─────────────────────────────────────────────────────────────────────┐
│ COGNISCIENT ARCHITECTURE │
└─────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────┐
│ GRAPH LAYER │
│ (Neo4j, Neptune, or similar) │
│ │
│ Nodes: Entities (people, projects, documents, concepts, events) │
│ Edges: Relationships (works_on, depends_on, influences, etc.) │
│ Properties: Attributes, metadata, timestamps, confidence │
│ │
│ Purpose: Structure, relationships, traversal, reasoning │
└─────────────────────────────────────────────────────────────────────┘
+
┌─────────────────────────────────────────────────────────────────────┐
│ VECTOR LAYER │
│ (Pinecone, Weaviate, Qdrant, or similar) │
│ │
│ Embeddings: Semantic representations of content │
│ Indices: Optimized for similarity search │
│ Metadata: Links back to graph entities │
│ │
│ Purpose: Semantic search, similarity matching, clustering │
└─────────────────────────────────────────────────────────────────────┘
+
┌─────────────────────────────────────────────────────────────────────┐
│ TEMPORAL LAYER │
│ (Time-series or event store) │
│ │
│ Events: What happened and when │
│ States: Entity state at points in time │
│ Deltas: What changed between observations │
│ │
│ Purpose: History, trends, temporal reasoning │
└─────────────────────────────────────────────────────────────────────┘
Each layer serves a different purpose:
| Query Type | Best Layer | Example |
|---|---|---|
| "What relates to X?" | Graph | Find all projects connected to Acme Corp |
| "Find similar to X" | Vector | Find documents like this proposal |
| "What happened when?" | Temporal | Show timeline of the sales process |
| "Who influences what?" | Graph | Trace decision-making chains |
| "What's relevant now?" | Vector + Graph | Context assembly for current task |
The fundamental unit of knowledge in Cogniscient.
Entity:
# Identity
entity_id: string (globally unique)
type: string (person | organization | project | document | event |
concept | product | process | location | asset | custom)
# Core Properties
name: string (human-readable identifier)
description: string (summary of what this entity is)
aliases: [strings] (other names this entity is known by)
# Classification
category: string (domain-specific classification)
tags: [strings] (searchable labels)
# Source & Provenance
source_system: string (where this entity originated)
source_id: string (ID in the source system)
created_by: string (who/what created this entity)
created_at: timestamp
updated_at: timestamp
# Confidence & Quality
confidence: 0-100 (certainty that this entity exists/is accurate)
completeness: 0-100 (how much we know about this entity)
verification_status: unverified | verified | disputed
# Lifecycle
status: active | archived | merged | deleted
valid_from: timestamp (when this entity became relevant)
valid_until: timestamp (when this entity ceased to be relevant)
# Type-Specific Properties
properties: object (varies by entity type)
# Embeddings (link to vector layer)
embedding_ids: [vector_ids] (semantic representations)
Person:
entity_id: "person_12345"
type: "person"
name: "Sarah Chen"
properties:
role: "VP of Engineering"
organization_id: "org_acme"
email: "sarah.chen@acme.com"
expertise: ["distributed systems", "team leadership"]
communication_style: "direct, data-driven"
Project:
entity_id: "project_67890"
type: "project"
name: "Platform Migration"
properties:
status: "in_progress"
phase: "pilot"
start_date: "2025-01-15"
target_completion: "2025-09-30"
owner_id: "person_12345"
stakeholders: ["person_111", "person_222"]
Event:
entity_id: "event_24680"
type: "event"
name: "Quarterly Review Meeting"
properties:
event_type: "meeting"
date: "2025-01-25"
duration_minutes: 60
participants: ["person_12345", "person_111"]
location: "virtual"
outcome: "decisions_made"
Concept:
entity_id: "concept_13579"
type: "concept"
name: "Phased Rollout Strategy"
properties:
definition: "Deploying in stages to reduce risk"
domain: "project_management"
related_concepts: ["risk_mitigation", "change_management"]
Connections between entities that carry meaning.
Relationship:
# Identity
relationship_id: string (globally unique)
# Connection
source_entity_id: string (from entity)
target_entity_id: string (to entity)
type: string (predicate describing the relationship)
# Semantics
predicate: string (verb phrase: "works_on", "depends_on", etc.)
description: string (human-readable explanation)
# Direction & Symmetry
direction: unidirectional | bidirectional
inverse_predicate: string (if bidirectional, the reverse label)
# Strength & Confidence
weight: 0-100 (strength/importance of relationship)
confidence: 0-100 (certainty that relationship exists)
# Temporal Properties
valid_from: timestamp (when relationship began)
valid_until: timestamp (when relationship ended, if applicable)
is_current: boolean (is this relationship active now)
# Provenance
source: string (how we learned about this relationship)
evidence: [references] (supporting information)
created_at: timestamp
updated_at: timestamp
# Properties
properties: object (relationship-specific attributes)
# Organizational Relationships
works_for: Person → Organization
manages: Person → Person
member_of: Person → Team
reports_to: Person → Person
# Project Relationships
works_on: Person → Project
owns: Person → Project
stakeholder_of: Person → Project
depends_on: Project → Project
blocks: Issue → Project
# Knowledge Relationships
authored: Person → Document
references: Document → Document
about: Document → Concept
expertise_in: Person → Concept
# Causal Relationships
causes: Event → Event
influences: Entity → Entity
enables: Entity → Entity
prevents: Entity → Entity
# Temporal Relationships
preceded_by: Event → Event
followed_by: Event → Event
during: Event → Event
# Association Relationships
related_to: Entity → Entity (generic)
similar_to: Entity → Entity
opposite_of: Concept → Concept
instance_of: Entity → Concept
A special entity type that captures interactions and their context.
Experience:
# Identity
experience_id: string
type: "experience"
# What Happened
summary: string (gist of the experience)
detailed_content: string (fuller description if needed)
# Participants
participants: [entity_ids] (who was involved)
primary_actor: entity_id (main person/agent)
# Context
context_type: conversation | meeting | transaction | observation | decision
channel: string (how it happened: chat, email, in-person, etc.)
location: entity_id (where it happened, if relevant)
# Temporal
occurred_at: timestamp
duration: duration (how long it lasted)
# Outcomes
outcome: string (what resulted)
decisions_made: [strings]
action_items: [strings]
# Emotional/Qualitative
sentiment: negative | neutral | positive | mixed
intensity: low | medium | high
# Relationships Created/Updated
entities_involved: [entity_ids]
relationships_affected: [relationship_ids]
# Learning
insights: [strings] (what we learned)
patterns_observed: [strings] (recurring themes)
# Links
related_outcomes: [outcome_ids] (ODIE outcomes affected)
follow_up_actions: [action_ids]
┌─────────────────────────────────────────────────────────────────────┐
│ INGESTION PIPELINE │
└─────────────────────────────────────────────────────────────────────┘
Raw Input (document, conversation, event, data)
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ 1. EXTRACTION │
│ - Parse content based on type │
│ - Extract text, metadata, structure │
│ - Identify language and encoding │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ 2. ENTITY RECOGNITION │
│ - Identify entities mentioned (people, orgs, concepts, etc.) │
│ - Match to existing entities or create new │
│ - Extract entity attributes │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ 3. RELATIONSHIP EXTRACTION │
│ - Identify relationships between entities │
│ - Classify relationship types │
│ - Assess relationship strength and confidence │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ 4. SUMMARIZATION / GISTING │
│ - Create concise summary of content │
│ - Extract key points, decisions, action items │
│ - Capture sentiment and qualitative aspects │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ 5. EMBEDDING GENERATION │
│ - Generate vector embeddings for semantic search │
│ - Create embeddings at multiple granularities │
│ - Link embeddings to entities │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ 6. GRAPH INTEGRATION │
│ - Create/update entity nodes │
│ - Create/update relationship edges │
│ - Update temporal history │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ 7. CONSISTENCY CHECK │
│ - Verify no contradictions with existing knowledge │
│ - Flag conflicts for resolution │
│ - Update confidence scores │
└─────────────────────────────────────────────────────────────────────┘
│
▼
Knowledge Graph Updated
┌─────────────────────────────────────────────────────────────────────┐
│ RETRIEVAL PIPELINE │
└─────────────────────────────────────────────────────────────────────┘
Query (natural language or structured)
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ 1. QUERY UNDERSTANDING │
│ - Parse query intent │
│ - Identify entities referenced │
│ - Determine query type (lookup, search, traverse, aggregate) │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ 2. MULTI-PATH RETRIEVAL │
│ - Graph traversal (follow relationships) │
│ - Vector search (semantic similarity) │
│ - Keyword search (exact matches) │
│ - Temporal query (time-based filtering) │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ 3. RESULT FUSION │
│ - Combine results from multiple retrieval paths │
│ - Score by relevance to query │
│ - Deduplicate overlapping results │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ 4. CONTEXT ENRICHMENT │
│ - Expand with related entities (1-2 hops) │
│ - Add temporal context (what was happening then) │
│ - Include relationship context (how things connect) │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ 5. PERMISSION FILTERING │
│ - Check user's access rights │
│ - Filter results to permitted entities │
│ - Redact sensitive content if needed │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ 6. RANKING & ASSEMBLY │
│ - Final relevance ranking │
│ - Assemble into coherent context package │
│ - Format for consumer (Archer, ODIE, etc.) │
└─────────────────────────────────────────────────────────────────────┘
│
▼
Context Package Returned
Determining when two references point to the same real-world entity.
Entity Resolution Process:
1. CANDIDATE GENERATION
- Find potential matches based on name similarity
- Find potential matches based on attribute overlap
- Find potential matches based on relationship overlap
2. FEATURE EXTRACTION
- Name similarity score
- Attribute match scores
- Relationship overlap score
- Temporal plausibility
3. MATCH DECISION
- Apply matching model (rules or ML)
- Threshold for automatic merge
- Flag borderline cases for review
4. MERGE EXECUTION (if matched)
- Combine attributes (prefer most recent/reliable)
- Merge relationships
- Update references
- Preserve provenance
Example:
Input: "S. Chen from Acme" mentioned in email
Candidates:
- "Sarah Chen" (person_12345) - confidence 92%
- "Steven Chen" (person_67890) - confidence 34%
Decision: Match to Sarah Chen
Action: Link email mention to person_12345
Discovering relationships that aren't explicitly stated.
Relationship Inference Patterns:
TRANSITIVE:
If A works_for B and B subsidiary_of C
Then A works_for C (inferred, lower confidence)
CO-OCCURRENCE:
If A and B frequently appear in same documents/meetings
Then A related_to B (inferred, confidence based on frequency)
TEMPORAL:
If A created before B and B references A
Then B depends_on A (inferred)
STRUCTURAL:
If A reports_to B and C reports_to B
Then A colleague_of C (inferred)
BEHAVIORAL:
If A always approves requests from B
Then A trusts B (inferred from pattern)
Identifying conflicting information in the knowledge graph.
Contradiction Types:
DIRECT CONTRADICTION:
Entity A has property X = "value1"
New information says property X = "value2"
Action: Flag for resolution, store both with timestamps
RELATIONSHIP CONTRADICTION:
A works_for B (current)
New info: A works_for C (not B)
Action: Check if job change or data error
TEMPORAL IMPOSSIBILITY:
Event A occurred before Event B
New info: Event B caused Event A
Action: Flag temporal inconsistency
LOGICAL INCONSISTENCY:
A is_a Manager
All Managers have direct_reports
A has no direct_reports
Action: Flag logical violation
Resolution Strategies:
- Prefer more recent information (with timestamp)
- Prefer more reliable sources (with source scoring)
- Prefer higher confidence information
- Escalate to human for critical contradictions
Building relevant context packages for specific tasks.
Context Assembly Process:
1. SEED IDENTIFICATION
- What is the primary focus? (entity, topic, task)
- What is the purpose? (decision, creation, analysis)
2. EXPANSION STRATEGY
- Breadth-first: Explore all relationships to depth N
- Relevance-guided: Follow most relevant paths first
- Goal-directed: Expand toward known relevant areas
3. CONTENT SELECTION
- Include entities directly related to seed
- Include relationships that explain connections
- Include temporal context (recent events, history)
- Include similar past experiences
4. PRUNING
- Remove low-relevance items
- Respect context size limits
- Prioritize by recency and importance
5. FORMATTING
- Structure for consumer (Archer prompt, ODIE evaluation)
- Include provenance for traceability
- Highlight key facts and relationships
Example Context Assembly:
Task: "Prepare for meeting with Acme Corp about Project X"
Seed: [Acme Corp, Project X, Meeting]
Assembled Context:
- Acme Corp profile (industry, size, our history)
- Key people at Acme (Sarah Chen - decision maker)
- Project X status (pilot phase, Q3 target)
- Recent interactions (last meeting: timeline concerns)
- Open issues (Sarah wants written agreement)
- Related outcomes (ODIE: "Close Acme deal by Q2")
- Similar past deals (what worked, what didn't)
Finding relevant information based on meaning, not just keywords.
Semantic Search Process:
1. QUERY EMBEDDING
- Convert query to vector representation
- Optionally expand query with synonyms/related terms
2. SIMILARITY SEARCH
- Find entities with similar embeddings
- Find experiences with similar content
- Find documents with similar themes
3. HYBRID SCORING
- Combine semantic similarity with:
- Recency (newer = more relevant)
- Importance (central entities = more relevant)
- Relationship distance (closer = more relevant)
- User context (personalized relevance)
4. RESULT RANKING
- Final scored and ranked list
- Diversification (avoid redundant results)
- Explanation of why each result is relevant
Example:
Query: "What do we know about their concerns with the timeline?"
Semantic Understanding:
- "their" → Acme Corp (from context)
- "concerns" → negative sentiment, issues, objections
- "timeline" → project schedule, deadlines, dates
Results:
1. Meeting notes (Jan 25): Sarah pushed back on Q2 timeline
2. Email thread: Discussion of internal constraints
3. Similar experience: Beta Corp also had timeline concerns (resolved with phased approach)
Not all information is equally important. Cogniscient weights entities and experiences:
Importance Factors:
RECENCY:
- More recent = higher base importance
- Decay function over time
FREQUENCY:
- Frequently referenced = higher importance
- Frequently updated = higher importance
CENTRALITY:
- More relationships = higher importance
- Hub entities are more important
OUTCOME LINKAGE:
- Connected to active outcomes = higher importance
- Connected to high-priority outcomes = higher importance
USER SIGNALS:
- Explicitly marked important = highest importance
- Frequently queried = higher importance
- Starred/bookmarked = higher importance
Importance Score =
(Recency × W1) +
(Frequency × W2) +
(Centrality × W3) +
(OutcomeLinkage × W4) +
(UserSignals × W5)
Some information should fade over time:
Decay Policies:
NO DECAY:
- Core entities (people, organizations)
- Verified facts
- Explicitly preserved items
SLOW DECAY:
- Relationship strengths (reduce if no reinforcement)
- Inferred relationships (reduce confidence over time)
- Historical events (compress detail over time)
FAST DECAY:
- Working memory items
- Tentative inferences
- Low-confidence observations
IMMEDIATE REMOVAL:
- Explicitly deleted items
- Privacy-expired data
- Superseded information
Decay Implementation:
- Periodic decay job (daily/weekly)
- Reduce importance scores by decay rate
- Archive when below threshold
- Delete when below archive threshold (or by policy)
Over time, similar memories should be consolidated:
Consolidation Triggers:
- Multiple similar experiences detected
- Pattern threshold crossed
- Manual consolidation request
Consolidation Process:
1. Identify similar items (semantic clustering)
2. Extract common patterns
3. Create summary entity (pattern or concept)
4. Link original items to summary
5. Optionally archive originals (keep summary)
Example:
Original: 12 separate meeting notes with Acme Corp
Consolidated:
- "Acme Corp Engagement Summary" (high-level)
- Key themes extracted
- Decision timeline
- Links to original notes (archived)
Archer Cogniscient
│ │
│ "Store: Meeting with Acme Corp │
│ about Project X timeline" │
│──────────────────────────────────▶│
│ │ [Extract entities]
│ │ [Extract relationships]
│ │ [Generate embeddings]
│ │ [Update graph]
│ "Stored. Created/updated: │
│ 3 entities, 5 relationships" │
│◀──────────────────────────────────│
│ │
│ "Retrieve: Context for Acme │
│ meeting prep" │
│──────────────────────────────────▶│
│ │ [Assemble context]
│ │ [Check permissions]
│ [Context package with entities, │
│ relationships, history, │
│ relevant experiences] │
│◀──────────────────────────────────│
Archer provides to Cogniscient:
Cogniscient provides to Archer:
ODIE Cogniscient
│ │
│ "Store outcome: Close Acme │
│ deal by Q2" │
│──────────────────────────────────▶│
│ │ [Create outcome entity]
│ │ [Link to related entities]
│ │
│ "Query: What entities relate │
│ to this outcome?" │
│──────────────────────────────────▶│
│ │
│ [Acme Corp, Project X, │
│ Sarah Chen, Q2 deadline, │
│ related projects...] │
│◀──────────────────────────────────│
│ │
│ "Store belief: Acme prefers │
│ phased rollouts" │
│──────────────────────────────────▶│
│ │ [Create belief entity]
│ │ [Link to evidence]
ODIE provides to Cogniscient:
Cogniscient provides to ODIE:
Fluxio Cogniscient
│ │
│ "Log execution: Task X completed │
│ by Agent Y with result Z" │
│──────────────────────────────────▶│
│ │ [Create execution record]
│ │ [Link to entities involved]
│ │
│ "Query: Past executions of │
│ similar tasks" │
│──────────────────────────────────▶│
│ │
│ [Similar past tasks, │
│ what worked, what didn't, │
│ performance patterns] │
│◀──────────────────────────────────│
Fluxio provides to Cogniscient:
Cogniscient provides to Fluxio:
Librarian Cogniscient
│ │
│ "Store: Resource performance │
│ data for Agent X" │
│──────────────────────────────────▶│
│ │ [Update agent entity]
│ │ [Store performance history]
│ │
│ "Query: Performance trends │
│ for SQL-related tasks" │
│──────────────────────────────────▶│
│ │
│ [Historical performance, │
│ contextual scores, │
│ trend analysis] │
│◀──────────────────────────────────│
Librarian provides to Cogniscient:
Cogniscient provides to Librarian:
# Create Entity
POST /entities
Request:
type: string
name: string
properties: object
relationships: [relationship_specs]
Response:
entity_id: string
created: boolean
merged_with: entity_id (if matched existing)
# Get Entity
GET /entities/{entity_id}
Response:
entity: full entity object
relationships: [relationships]
recent_experiences: [experiences]
# Update Entity
PUT /entities/{entity_id}
Request:
properties: object (partial update)
Response:
entity: updated entity
# Delete Entity
DELETE /entities/{entity_id}
Response:
deleted: boolean
cascaded: [affected_relationships]
# Search Entities
POST /entities/search
Request:
query: string (natural language or structured)
types: [entity_types] (filter)
limit: number
Response:
entities: [entity_summaries with relevance scores]
# Create Relationship
POST /relationships
Request:
source_entity_id: string
target_entity_id: string
type: string
properties: object
Response:
relationship_id: string
# Query Relationships
POST /relationships/query
Request:
entity_id: string (starting point)
relationship_types: [types] (filter)
direction: outbound | inbound | both
depth: number (hops)
Response:
relationships: [relationships with connected entities]
# Traverse Graph
POST /graph/traverse
Request:
start_entity_id: string
pattern: traversal_pattern (e.g., "works_on->depends_on")
max_depth: number
filters: object
Response:
paths: [paths found]
entities: [entities encountered]
# Store Experience
POST /experiences
Request:
summary: string
participants: [entity_ids]
context_type: string
occurred_at: timestamp
outcomes: object
raw_content: string (optional)
Response:
experience_id: string
entities_created: [entity_ids]
relationships_created: [relationship_ids]
# Query Experiences
POST /experiences/query
Request:
entity_ids: [involved entities]
time_range: {from, to}
context_types: [types]
semantic_query: string
Response:
experiences: [experiences with relevance scores]
# Assemble Context
POST /context/assemble
Request:
seed_entities: [entity_ids]
purpose: string (what context is for)
max_tokens: number (size limit)
include:
relationships: boolean
experiences: boolean
temporal: boolean
similar: boolean
Response:
context_package:
entities: [relevant entities]
relationships: [relevant relationships]
experiences: [relevant experiences]
summary: string (narrative summary)
# Semantic Search
POST /search/semantic
Request:
query: string
entity_types: [types] (filter)
time_range: {from, to}
limit: number
Response:
results: [items with similarity scores and explanations]
# Check Consistency
POST /consistency/check
Request:
entity_id: string (optional, check specific entity)
scope: full | recent (how much to check)
Response:
consistent: boolean
contradictions: [contradiction_details]
# Resolve Contradiction
POST /consistency/resolve
Request:
contradiction_id: string
resolution: keep_first | keep_second | keep_both | manual
rationale: string
Response:
resolved: boolean
changes_made: [changes]
Scenario: New employee onboarding
Without Cogniscient:
- Employee reads static documentation
- Asks colleagues repeated questions
- Slowly builds mental map of organization
- Knowledge is fragmented and incomplete
With Cogniscient:
- "Tell me about Project X"
→ Full context: history, people, decisions, status, related projects
- "Who should I talk to about the API design?"
→ Sarah Chen (expertise: API design, available, worked on similar)
- "What happened in last quarter's planning?"
→ Summary of meetings, decisions made, outcomes, follow-ups
- "How does our team relate to the Platform team?"
→ Organizational relationship, shared projects, key contacts
Scenario: NPC remembers player across sessions
Without Cogniscient:
- NPC resets every session
- "Who are you again?"
- No relationship development
- No consequence for actions
With Cogniscient:
- Player helped NPC in Session 1
→ Stored: Experience (player helped, positive outcome)
→ Stored: Relationship (player -> NPC: helped, trust +20)
- Session 5, player returns:
→ Retrieved: "Ah, my friend! You helped me with those bandits."
→ Behavior modified: More trusting, offers better prices
→ Remembers details: "How is your quest for the ancient sword?"
- Player betrayed NPC in Session 7:
→ Updated: Relationship (trust -50)
→ New experience: betrayal, negative outcome
→ Behavior modified: Suspicious, guards information
Scenario: Personal knowledge management
Cogniscient stores:
- Conversations with doctors (health context)
- Career discussions and decisions
- Relationship events and patterns
- Learning and growth experiences
- Financial decisions and outcomes
User asks: "What did my doctor say about my medication last time?"
→ Retrieved: Dr. Smith appointment (March 15)
→ Summary: Discussed switching from X to Y, follow-up in 3 months
→ Related: Previous side effects, lab results
User asks: "What patterns do you see in my career decisions?"
→ Analysis: Tends to prioritize learning over salary
→ Observation: Most satisfied after collaborative roles
→ Insight: Last 3 job changes followed similar pattern
Graph Database Options:
- Neo4j (mature, feature-rich, good for complex queries)
- Amazon Neptune (managed, AWS integration)
- ArangoDB (multi-model: graph + document)
- TigerGraph (high performance, good for analytics)
Vector Database Options:
- Pinecone (managed, easy to use)
- Weaviate (open source, hybrid search)
- Qdrant (open source, high performance)
- Milvus (open source, scalable)
- pgvector (PostgreSQL extension, simpler deployment)
Embedding Models:
- OpenAI text-embedding-3-large (high quality, API cost)
- Cohere embed (good multilingual)
- Sentence Transformers (open source, self-hosted)
- Custom fine-tuned models (domain-specific)
For MVP, implement:
Skip for MVP:
Horizontal Scaling:
- Shard graph by entity type or tenant
- Partition vector indices
- Distributed query execution
Performance Optimization:
- Cache hot entities and relationships
- Pre-compute common traversal patterns
- Batch embedding generation
- Async indexing for writes
Data Management:
- Tiered storage (hot/warm/cold)
- Archival policies for old data
- Compliance with data retention requirements
Principles:
- Minimize data collection (store gist, not raw)
- Encrypt at rest and in transit
- Respect source system permissions
- Enable data deletion/export (GDPR compliance)
Access Control:
- Entity-level permissions
- Relationship visibility rules
- Query result filtering
- Audit all access
Sensitive Data Handling:
- Identify PII during ingestion
- Apply appropriate protections
- Redact in query results if not permitted
- Special handling for health, financial, etc.
Isolation Models:
SHARED DATABASE, TENANT COLUMN:
- All tenants in same database
- Tenant ID on every record
- Query filtering required
- Lower cost, higher risk
SEPARATE SCHEMAS:
- Each tenant has own schema
- Same database instance
- Better isolation, more complex
SEPARATE DATABASES:
- Complete isolation
- Higher cost
- Simplest security model
Recommendation: Start with separate schemas,
migrate to separate databases for enterprise clients
Cogniscient is the adaptive intelligence substrate—the component that gives AI systems persistent, contextual, evolving memory.
Key Characteristics:
Integration Role:
The Core Insight:
Cogniscient stores experiences, not just facts. It understands relationships, not just data. It enables contextual intelligence, not just retrieval.
Document created January 2026