The Universal Knowledge Protocol: Noun-Verb Taxonomy

Brainy is the Universal Knowledge Protocol™ powered by Triple Intelligence™

Brainy unifies vector, graph, and document search behind one API. That unification — Triple Intelligence — rests on a shared, standardized vocabulary for knowledge: a fixed set of entity types (nouns) and relationship types (verbs) that every tool, integration, and model can speak.

Every example on this page is written against the real Brainy 8.0 API. The setup is always the same:

import { Brainy, NounType, VerbType } from '@soulcraft/brainy'

const brain = new Brainy()
await brain.init()

• brain.add({ data, type, subtype?, metadata? }) creates a noun and returns its string id.

• brain.relate({ from, to, type, metadata? }) creates a verb (relationship) between two nouns.

• brain.find({ query?, type?, where?, connected? }) runs Triple Intelligence search.

• brain.related({ from }) / brain.neighbors(id) read a noun's relationships.

Universal & Infinite Expressiveness

Brainy's Noun-Verb Taxonomy achieves broad coverage of human knowledge through composable expressiveness:

• 42 Noun Types × 127 Verb Types = 5,334 Base Combinations

• Unlimited Metadata Fields = Domain Specificity

• Multi-hop Graph Traversals = Relationship Complexity

• Result: Model data across virtually any industry

Every piece of information can be represented as entities (nouns) connected by relationships (verbs) carrying properties (metadata). The standardized type system from @soulcraft/brainy (NounType, VerbType) gives those nouns and verbs a stable, shared name.

The Power of Standardization: Universal Interoperability

Why Standardized Types = Seamless Integration

Because every entity is classified with a NounType and every relationship with a VerbType, the same data is legible to any code that imports the same enums.

1. Tool Interoperability

// Any tool that understands Brainy's NounType/VerbType can read the same graph.
// One module writes; another reads — no schema translation in between.
const authors = await brain.find({ type: NounType.Person })

for (const author of authors) {
  const authored = await brain.related({
    from: author.id,
    type: VerbType.Creates
  })
  console.log(`${author.data} → ${authored.length} document(s)`)
}

2. Data Portability

// Snapshot one brain and open it as another — the noun/verb vocabulary
// travels with the data, so the types line up exactly.
const pin = brain1.now()
try {
  await pin.persist('/snapshots/brain-1')
} finally {
  await pin.release()
}

const brain2 = await Brainy.load('/snapshots/brain-1') // same NounType/VerbType vocabulary

3. Model & Agent Compatibility

// Different models and agents reason over the SAME typed structure.
// Whatever produced the entity, every consumer reads the same NounType.
const conceptId = await brain.add({
  data: 'Quantum Computer',
  type: NounType.Thing,
  subtype: 'computing-hardware'
})

// Any downstream consumer can now retrieve and reason about this entity.
const concept = await brain.get(conceptId)
console.log(concept?.type) // 'thing'

4. Extensibility Without Forking the Schema

// Subtypes extend a standard NounType for a specific domain — no schema
// migration, no new noun type. The base type stays universally understood.
await brain.add({ data: 'Patient #12345', type: NounType.Person, subtype: 'patient' })
await brain.add({ data: 'Invoice #4471', type: NounType.Document, subtype: 'invoice' })
await brain.add({ data: 'Follower edge', type: NounType.Relationship, subtype: 'social-graph' })

// Domains that share the base types interoperate even with custom subtypes.
const patients = await brain.find({ type: NounType.Person, subtype: 'patient' })

5. Cross-Platform Integration

// Map external systems onto the standard taxonomy. A CRM's Contact/Account/
// Opportunity become Person/Organization/Event — the same vocabulary everywhere.
const externalRecords = [
  { kind: 'Contact', name: 'Dana Lee', type: NounType.Person },
  { kind: 'Account', name: 'Acme Corp', type: NounType.Organization },
  { kind: 'Opportunity', name: 'Q3 Renewal', type: NounType.Event }
]

for (const record of externalRecords) {
  await brain.add({
    data: record.name,
    type: record.type,
    metadata: { source: 'crm', externalKind: record.kind }
  })
}

The Network Effect: Brainy as the Universal Knowledge Protocol

Like HTTP became the protocol for the web and TCP/IP for the internet, Brainy's noun-verb taxonomy aims to be a Universal Knowledge Protocol:

• Learn Once: Developers learn 42 nouns + 127 verbs, not thousands of bespoke schemas

• Build Anywhere: Tools built for one domain work in others

• Share Everything: Knowledge graphs are universally shareable

• Compose Freely: Subtypes and metadata extend types without schema migrations

This isn't just a database — it's a shared model for how knowledge is represented.

Overview

Brainy's Noun-Verb Taxonomy models data as entities (nouns) and relationships (verbs), creating a semantic knowledge graph that mirrors how humans naturally think about information.

Why Noun-Verb?

Traditional databases force you to think in tables, documents, or nodes. Brainy lets you think naturally:

• Nouns: Things that exist (people, documents, products, concepts)

• Verbs: How things relate (creates, owns, references, related-to)

This simple mental model scales from basic storage to complex knowledge graphs while remaining intuitive.

Core Concepts

Nouns (Entities)

Nouns represent any entity in your system. add() takes a single object and returns the new entity's id:

// Add any entity as a noun
const personId = await brain.add({
  data: 'John Smith, Senior Engineer',
  type: NounType.Person,
  subtype: 'employee',
  metadata: { department: 'engineering', skills: ['TypeScript', 'React', 'Node.js'] }
})

const documentId = await brain.add({
  data: 'Q3 2024 Financial Report',
  type: NounType.Document,
  subtype: 'report',
  metadata: { category: 'financial', confidential: true, created: '2024-10-01' }
})

const conceptId = await brain.add({
  data: 'Machine Learning',
  type: NounType.Concept,
  metadata: { domain: 'technology', complexity: 'advanced' }
})

Noun Properties

Every noun automatically gets:

• Unique ID: System-generated UUID, or supply your own via id

• Vector Embedding: data is embedded for semantic similarity

• Metadata: Flexible, queryable JSON properties

• Timestamps: createdAt / updatedAt tracking

• Indexing: Automatic field indexing for where filters

Verbs (Relationships)

Verbs define how nouns relate to each other. relate() also takes a single object:

// Create relationships between entities
await brain.relate({
  from: personId,
  to: documentId,
  type: VerbType.Creates,
  metadata: { role: 'primary_author', contribution: '80%' }
})

await brain.relate({
  from: documentId,
  to: conceptId,
  type: VerbType.Describes,
  metadata: { sections: ['methodology', 'results'], depth: 'detailed' }
})

await brain.relate({
  from: personId,
  to: conceptId,
  type: VerbType.RelatedTo,
  subtype: 'expertise',
  metadata: { yearsExperience: 5, certification: 'Advanced ML Certification' }
})

Verb Properties

Every verb includes:

• Source (from): The noun initiating the relationship

• Target (to): The noun receiving the relationship

• Type: The VerbType classification

• Subtype: Optional per-product sub-classification (fast-path indexed)

• Metadata: Relationship-specific queryable data

• Weight: Optional relationship strength (0–1)

Benefits

1. Natural Mental Model

// Think naturally about your data
const taskId = await brain.add({ data: 'Implement payment system', type: NounType.Task })
const userId = await brain.add({ data: 'Alice Johnson', type: NounType.Person })
const projectId = await brain.add({ data: 'E-commerce Platform', type: NounType.Project })

// Express relationships clearly
await brain.relate({ from: userId, to: taskId, type: VerbType.ParticipatesIn, subtype: 'assignee' })
await brain.relate({ from: taskId, to: projectId, type: VerbType.PartOf })
await brain.relate({ from: userId, to: projectId, type: VerbType.ParticipatesIn, subtype: 'manager' })

2. Semantic Understanding

The noun-verb model preserves meaning. find() accepts a natural-language string or a structured query:

// Natural language — embedded and matched semantically
const results = await brain.find({ query: 'tasks for the payment system' })

// Structured — type + graph traversal in one call
const aliceTasks = await brain.find({
  type: NounType.Task,
  connected: { from: userId, via: VerbType.ParticipatesIn }
})

3. Flexible Schema

No rigid schema requirements — add any type, extend with a subtype:

// Add any noun type without schema changes
const sensorId = await brain.add({
  data: 'New IoT Sensor',
  type: NounType.Thing,
  subtype: 'iot-device',
  metadata: { protocol: 'MQTT', location: 'Building A' }
})

const buildingId = await brain.add({ data: 'Building A', type: NounType.Location })

// Relationships carry their own structured metadata
await brain.relate({
  from: sensorId,
  to: buildingId,
  type: VerbType.Measures,
  metadata: { metrics: ['temperature', 'humidity'], interval: '5 minutes' }
})

4. Graph Traversal

Navigate relationships naturally with connected:

// Find documents reachable from a team via two relationship hops
const teamDocs = await brain.find({
  type: NounType.Document,
  connected: {
    from: teamId,
    via: [VerbType.MemberOf, VerbType.Creates],
    depth: 2
  }
})

// Find products two hops out from a user
const recommendations = await brain.find({
  type: NounType.Product,
  connected: {
    from: userId,
    via: VerbType.Owns,
    depth: 2
  }
})

5. Temporal Relationships

Track how relationships change over time by storing dates in edge metadata:

await brain.relate({
  from: employeeId,
  to: companyId,
  type: VerbType.MemberOf,
  subtype: 'past-employment',
  metadata: { from: '2020-01-01', to: '2023-12-31', position: 'Senior Developer' }
})

await brain.relate({
  from: employeeId,
  to: newCompanyId,
  type: VerbType.MemberOf,
  subtype: 'current-employment',
  metadata: { from: '2024-01-01', position: 'Tech Lead' }
})

// Query with natural language
const employment = await brain.find({ query: 'where did this person work in 2022' })

Real-World Use Cases

Knowledge Management

// Documents and their relationships
const paperId = await brain.add({
  data: 'Neural Networks Paper',
  type: NounType.Document,
  subtype: 'research-paper',
  metadata: { year: 2024 }
})

const authorId = await brain.add({
  data: 'Dr. Sarah Chen',
  type: NounType.Person,
  subtype: 'researcher'
})

const topicId = await brain.add({ data: 'Deep Learning', type: NounType.Concept })
const otherPaperId = await brain.add({ data: 'Backpropagation Survey', type: NounType.Document })

// Rich relationship network
await brain.relate({ from: authorId, to: paperId, type: VerbType.Creates })
await brain.relate({ from: paperId, to: topicId, type: VerbType.Describes })
await brain.relate({ from: paperId, to: otherPaperId, type: VerbType.References })
await brain.relate({ from: authorId, to: topicId, type: VerbType.RelatedTo, subtype: 'research-focus' })

// Query the knowledge graph
const related = await brain.find({ query: 'papers about deep learning by Sarah Chen' })

Social Networks

// Users and connections
const user1 = await brain.add({ data: 'Alice', type: NounType.Person })
const user2 = await brain.add({ data: 'Bob', type: NounType.Person })
const post = await brain.add({ data: 'Great article on AI!', type: NounType.Message, subtype: 'post' })

// Social interactions
await brain.relate({ from: user1, to: user2, type: VerbType.Follows })
await brain.relate({ from: user2, to: user1, type: VerbType.Follows }) // mutual
await brain.relate({ from: user1, to: post, type: VerbType.Creates })
await brain.relate({ from: user2, to: post, type: VerbType.Likes })
await brain.relate({ from: user2, to: post, type: VerbType.Communicates, subtype: 'share' })

// Find social patterns
const influencers = await brain.find({ query: 'people who post about AI with many followers' })

E-commerce

// Products and purchases
const product = await brain.add({
  data: 'Wireless Headphones',
  type: NounType.Product,
  metadata: { price: 99.99, category: 'electronics' }
})

const customer = await brain.add({
  data: 'Customer #12345',
  type: NounType.Person,
  subtype: 'customer',
  metadata: { tier: 'premium' }
})

// Purchase and review relationships
await brain.relate({
  from: customer,
  to: product,
  type: VerbType.Owns,
  subtype: 'purchase',
  metadata: { date: '2024-01-15', quantity: 1, price: 99.99 }
})

await brain.relate({
  from: customer,
  to: product,
  type: VerbType.Evaluates,
  subtype: 'review',
  metadata: { rating: 5, text: 'Excellent sound quality!' }
})

// Recommendation queries
const recs = await brain.find({ query: 'products bought by customers who bought headphones' })

Project Management

// Projects, tasks, and teams
const project = await brain.add({ data: 'Website Redesign', type: NounType.Project })
const task = await brain.add({ data: 'Update homepage', type: NounType.Task })
const otherTask = await brain.add({ data: 'Design system audit', type: NounType.Task })
const developer = await brain.add({ data: 'Jane Developer', type: NounType.Person, subtype: 'employee' })
const designer = await brain.add({ data: 'John Designer', type: NounType.Person, subtype: 'employee' })

// Work relationships
await brain.relate({ from: task, to: project, type: VerbType.PartOf })
await brain.relate({ from: developer, to: task, type: VerbType.ParticipatesIn, subtype: 'assignee' })
await brain.relate({ from: designer, to: developer, type: VerbType.WorksWith })
await brain.relate({ from: task, to: otherTask, type: VerbType.DependsOn })

// Project queries
const blockers = await brain.find({ query: 'tasks blocked by incomplete work' })
const workload = await brain.find({ query: 'people assigned to multiple active projects' })

Advanced Patterns

Bidirectional Relationships

// Symmetric relationships create the inverse edge automatically
await brain.relate({ from: user1, to: user2, type: VerbType.FriendOf, bidirectional: true })

Weighted Relationships

// Add strength/weight to relationships (top-level weight, 0–1)
await brain.relate({
  from: doc1,
  to: doc2,
  type: VerbType.SimilarityDegree,
  weight: 0.95,
  metadata: { algorithm: 'cosine' }
})

// Weights come back on the Relation, so you can filter on them
const edges = await brain.related({ from: doc1, type: VerbType.SimilarityDegree })
const stronglyRelated = edges.filter((edge) => (edge.weight ?? 0) >= 0.8)

Relationship Chains (Multi-hop)

// Follow a chain of relationship types out to a fixed depth.
// `via` accepts an array of VerbTypes; `depth` bounds the traversal.
const results = await brain.find({
  type: NounType.Thing,
  connected: {
    from: userId,
    via: [VerbType.Owns, VerbType.Creates, VerbType.Uses],
    depth: 3
  }
})
// Finds: things used by products made by companies owned by the user

Meta-Relationships

Relationships can themselves be reasoned about. The Relationship NounType reifies an edge as a first-class entity, and the meta-level verbs (Endorses, Supports, Contradicts, Supersedes) express second-order claims between entities:

// A second person endorses a claim, and a third supports it with evidence.
const claim = await brain.add({ data: 'X improves retention', type: NounType.Proposition })
await brain.relate({ from: user2, to: claim, type: VerbType.Endorses })
await brain.relate({
  from: user3,
  to: claim,
  type: VerbType.Supports,
  metadata: { reason: 'Matches the A/B test', trustScore: 0.9 }
})

Query Patterns

Finding Nouns

// By type
const people = await brain.find({ type: NounType.Person })

// By type + metadata filters (bare operators — no `$` prefixes)
const documents = await brain.find({
  type: NounType.Document,
  where: {
    confidential: false,
    created: { gte: '2024-01-01' }
  }
})

// By semantic similarity — use `query`, optionally narrowed by type
const similar = await brain.find({
  query: 'machine learning research',
  type: NounType.Document
})

where operators are bare (never dollar-prefixed): eq/equals/is, ne/notEquals, in/oneOf, gt/greaterThan, gte/greaterThanOrEqual, lt/lessThan, lte/lessThanOrEqual, between, contains, exists, missing, plus the logical combinators allOf/anyOf/not.

Finding Verbs (Relationships)

// All relationships originating from a noun
const outgoing = await brain.related({ from: nounId })

// Every edge touching a noun, in either direction
const incident = await brain.related({ node: nounId })

// Filter by relationship type
const authorships = await brain.related({ from: authorId, type: VerbType.Creates })

// Filter returned relationships by their metadata (Relation carries `.metadata`)
const purchases = await brain.related({ from: customerId, type: VerbType.Owns, subtype: 'purchase' })
const recentPurchases = purchases.filter((edge) => edge.metadata?.date >= '2024-01-01')

// Just the count of relationships in the graph
const totalEdges = await brain.getVerbCount()

Combined Queries (Query → Expand)

// Start from a semantic query, then expand along the graph.
// Vector + graph in a single find() call.
const results = await brain.find({
  query: 'AI research',
  connected: {
    via: VerbType.Creates,
    depth: 2
  }
})

The Complete Noun Taxonomy (42 Types)

NounType is the stable, exported vocabulary for classifying entities. Every value is a plain string, so you can write NounType.Person or the literal 'person'. Pick the closest standard type and refine with subtype and metadata.

const physicistId = await brain.add({
  data: 'Albert Einstein',
  type: NounType.Person,
  metadata: { role: 'physicist', born: '1879-03-14' }
})

Core Entity Types (7)

Biological & Material Types (2)

Property, Temporal & Functional Types (3)

Informational Type (1)

Digital/Content Types (4)

Collection Types (2)

Business/Application Types (4)

Descriptive Types (6)

Scientific & Legal Types (4)

Technical Infrastructure Types (2)

Social Structure Types (3)

Information Theory Types (2)

Meta-Level & Extensible Types (2)

The Complete Verb Taxonomy (127 Types)

VerbType is the exported vocabulary for classifying relationships. As with nouns, every value is a plain string — write VerbType.Creates or 'creates'. Where no verb is an exact fit, choose the closest base verb and refine it with subtype and metadata (see Coverage Completeness).

await brain.relate({ from: authorId, to: documentId, type: VerbType.Creates })

Foundational Ontological (3)

Core Relationships (4)

Spatial (2)

Temporal (3)

Causal & Dependency (5)

Creation & Transformation (5)

Lifecycle (1)

Ownership & Attribution (2)

Property & Quality (2)

Effects & Experience (1)

Composition (2)

Social & Organizational (8)

Descriptive & Functional (8)

Advanced Relationships (5)

Modal (6)

Epistemic States (9)

Learning & Cognition (1)

Uncertainty & Probability (4)

Scalar Properties (5)

Information Theory (2)

Deontic (5)

Context & Perspective (5)

Advanced Temporal (6)

Advanced Spatial (9)

Social Structures (5)

Measurement (4)

Change & Persistence (4)

Parthood Variations (4)

Dependency Variations (3)

Meta-Level (4)

Coverage Completeness Analysis

Is Anything Missing?

The taxonomy is intentionally bounded. When no type is an exact fit, three escape hatches keep it complete:

1. Generic Fallbacks

• Custom noun type: For any entity that doesn't fit a standard type

• RelatedTo verb type: For any relationship not explicitly named

• subtype + metadata: Refine a base type with domain-specific semantics

2. Semantic Flexibility Through Subtype & Metadata

Instead of adding ever more verb types, refine a base verb with a subtype and structured metadata:

// "approves" → Evaluates with a result
await brain.relate({
  from: managerId,
  to: requestId,
  type: VerbType.Evaluates,
  subtype: 'approval',
  metadata: { result: 'approved', timestamp: Date.now() }
})

// "shares" → Communicates with an action
await brain.relate({
  from: userId,
  to: documentId,
  type: VerbType.Communicates,
  subtype: 'share',
  metadata: { permissions: 'read-only' }
})

// "delegates" → ParticipatesIn with a role + delegation metadata
await brain.relate({
  from: employeeId,
  to: taskId,
  type: VerbType.ParticipatesIn,
  subtype: 'delegate',
  metadata: { delegatedBy: managerId, authority: 'full' }
})

3. Edge Cases Are Covered

Even exotic scenarios fit the standard types:

// Quantum computing
const qubitId = await brain.add({
  data: 'Qubit-1',
  type: NounType.Thing,
  subtype: 'quantum-bit',
  metadata: { superposition: [0.707, 0.707] }
})

// Cryptocurrency transactions
const txId = await brain.add({
  data: 'Bitcoin Transfer',
  type: NounType.Event,
  subtype: 'blockchain-transaction',
  metadata: { hash: '1A2B3C...' }
})

// AI model training
const modelId = await brain.add({
  data: 'Neural Network',
  type: NounType.Process,
  subtype: 'ml-model',
  metadata: { architecture: 'transformer' }
})

The Philosophy: Simplicity Over Specificity

A bounded type system stays learnable:

1. A fixed vocabulary is easier to learn than thousands of bespoke schemas

2. Subtype + metadata provide open-ended extensibility

3. Consistent patterns carry across domains

4. No taxonomy explosion as new use cases appear

Industry-Specific Coverage Analysis

Why 42 Nouns + 127 Verbs = Broad Coverage

The combination of 42 noun types and 127 verb types yields 5,334 base combinations, and with subtypes, metadata, and multi-hop relationships that expands to cover essentially any domain. Here's how it maps onto common industries.

Healthcare & Medical

const patientId = await brain.add({
  data: 'John Doe',
  type: NounType.Person,
  subtype: 'patient',
  metadata: { mrn: '12345' }
})

const diagnosisId = await brain.add({
  data: 'Type 2 Diabetes',
  type: NounType.State,
  subtype: 'diagnosis',
  metadata: { icd10: 'E11.9' }
})

const medicationId = await brain.add({
  data: 'Metformin',
  type: NounType.Substance,
  subtype: 'medication',
  metadata: { dosage: '500mg' }
})

const doctorId = await brain.add({ data: 'Dr. Reyes', type: NounType.Person, subtype: 'physician' })

// Medical relationships
await brain.relate({ from: patientId, to: diagnosisId, type: VerbType.HasQuality, subtype: 'diagnosis' })
await brain.relate({ from: medicationId, to: diagnosisId, type: VerbType.Affects, subtype: 'treats' })
await brain.relate({ from: doctorId, to: patientId, type: VerbType.RelatedTo, subtype: 'treats' })

Finance & Banking

const accountId = await brain.add({
  data: 'Checking Account',
  type: NounType.Thing,
  subtype: 'account',
  metadata: { balance: 10000 }
})

const transactionId = await brain.add({
  data: 'Wire Transfer',
  type: NounType.Event,
  subtype: 'transaction',
  metadata: { amount: 5000 }
})

const regulationId = await brain.add({
  data: 'KYC Requirement',
  type: NounType.Regulation,
  subtype: 'compliance'
})

const customerId = await brain.add({ data: 'Account Holder', type: NounType.Person, subtype: 'customer' })

// Financial relationships
await brain.relate({ from: customerId, to: accountId, type: VerbType.Owns })
await brain.relate({ from: transactionId, to: accountId, type: VerbType.Modifies })
await brain.relate({ from: accountId, to: regulationId, type: VerbType.ConformsTo })

Manufacturing & Supply Chain

const factoryId = await brain.add({
  data: 'Plant #3',
  type: NounType.Location,
  subtype: 'facility'
})

const assemblyLineId = await brain.add({
  data: 'Assembly Line A',
  type: NounType.Process,
  subtype: 'production'
})

const componentId = await brain.add({
  data: 'Circuit Board v2',
  type: NounType.Thing,
  subtype: 'component'
})

const productId = await brain.add({ data: 'Controller Unit', type: NounType.Product })
const supplierId = await brain.add({ data: 'Acme Components', type: NounType.Organization, subtype: 'supplier' })

// Manufacturing relationships
await brain.relate({ from: assemblyLineId, to: componentId, type: VerbType.Creates })
await brain.relate({ from: componentId, to: productId, type: VerbType.PartOf })
await brain.relate({ from: supplierId, to: componentId, type: VerbType.RelatedTo, subtype: 'supplies' })

Education & Learning

const courseId = await brain.add({
  data: 'Machine Learning 101',
  type: NounType.Collection,
  subtype: 'course'
})

const lessonId = await brain.add({
  data: 'Neural Networks',
  type: NounType.Document,
  subtype: 'lesson'
})

const assessmentId = await brain.add({
  data: 'Final Exam',
  type: NounType.Event,
  subtype: 'assessment'
})

const studentId = await brain.add({ data: 'Student #88', type: NounType.Person, subtype: 'student' })

// Educational relationships
await brain.relate({ from: studentId, to: courseId, type: VerbType.MemberOf, subtype: 'enrolled' })
await brain.relate({ from: courseId, to: lessonId, type: VerbType.Contains })
await brain.relate({ from: studentId, to: assessmentId, type: VerbType.ParticipatesIn, subtype: 'completed' })

Legal & Compliance

const contractId = await brain.add({
  data: 'Service Agreement',
  type: NounType.Contract,
  subtype: 'service-agreement'
})

const clauseId = await brain.add({
  data: 'Liability Clause',
  type: NounType.Document,
  subtype: 'clause'
})

const caseId = await brain.add({
  data: 'Case #2024-1234',
  type: NounType.Event,
  subtype: 'legal-case'
})

const partyId = await brain.add({ data: 'Counterparty LLC', type: NounType.Organization })

// Legal relationships
await brain.relate({ from: contractId, to: clauseId, type: VerbType.Contains })
await brain.relate({ from: partyId, to: contractId, type: VerbType.RelatedTo, subtype: 'signatory' })
await brain.relate({ from: caseId, to: contractId, type: VerbType.References })

Retail & E-commerce

const productId = await brain.add({
  data: 'Wireless Earbuds',
  type: NounType.Product,
  metadata: { sku: 'WE-128-BLK' }
})

const cartId = await brain.add({
  data: 'Shopping Cart',
  type: NounType.Collection,
  subtype: 'cart'
})

const promotionId = await brain.add({
  data: 'Holiday Sale',
  type: NounType.Event,
  subtype: 'promotion'
})

const customerId = await brain.add({ data: 'Customer #5521', type: NounType.Person, subtype: 'customer' })

// Retail relationships
await brain.relate({ from: customerId, to: productId, type: VerbType.RelatedTo, subtype: 'view' })
await brain.relate({ from: cartId, to: productId, type: VerbType.Contains })
await brain.relate({ from: promotionId, to: productId, type: VerbType.Affects, subtype: 'applies' })

Real Estate

const propertyId = await brain.add({
  data: '123 Main St',
  type: NounType.Location,
  subtype: 'property'
})

const listingId = await brain.add({
  data: 'MLS #789',
  type: NounType.Document,
  subtype: 'listing'
})

const inspectionId = await brain.add({
  data: 'Home Inspection',
  type: NounType.Event,
  subtype: 'inspection'
})

const ownerId = await brain.add({ data: 'Property Owner', type: NounType.Person })

// Real estate relationships
await brain.relate({ from: ownerId, to: propertyId, type: VerbType.Owns })
await brain.relate({ from: listingId, to: propertyId, type: VerbType.Describes })
await brain.relate({ from: inspectionId, to: propertyId, type: VerbType.Evaluates })

Government & Public Sector

const citizenId = await brain.add({
  data: 'Citizen #123',
  type: NounType.Person,
  subtype: 'citizen'
})

const permitId = await brain.add({
  data: 'Building Permit',
  type: NounType.Document,
  subtype: 'permit'
})

const departmentId = await brain.add({
  data: 'Planning Dept',
  type: NounType.Organization,
  subtype: 'government'
})

const propertyId = await brain.add({ data: '500 Oak Ave', type: NounType.Location, subtype: 'property' })

// Government relationships
await brain.relate({ from: citizenId, to: permitId, type: VerbType.RelatedTo, subtype: 'request' })
await brain.relate({ from: departmentId, to: permitId, type: VerbType.Creates, subtype: 'issues' })
await brain.relate({ from: permitId, to: propertyId, type: VerbType.PermittedTo, subtype: 'authorizes' })

Why This Covers Most Knowledge

1. Structural Completeness

The noun-verb model forms a graph structure where:

• Any entity can be represented as a noun

• Any relationship can be represented as a verb

• Complex knowledge emerges from simple combinations

2. Semantic Coverage

Most information falls into one of these categories:

• Entities (who, what, where) → Nouns

• Actions/relations (how, when, why) → Verbs

• Attributes (properties) → Metadata

• Context (conditions) → Graph structure

3. Compositional Power

Simple types combine to represent complex knowledge:

const researchPaper = await brain.add({ data: 'AI Ethics Study', type: NounType.Document })
const researcher = await brain.add({ data: 'Dr. Smith', type: NounType.Person })
const institution = await brain.add({ data: 'MIT', type: NounType.Organization })
const concept = await brain.add({ data: 'AI Ethics', type: NounType.Concept })

// A rich knowledge graph emerges from a handful of typed edges
await brain.relate({ from: researcher, to: researchPaper, type: VerbType.Creates })
await brain.relate({ from: researcher, to: institution, type: VerbType.MemberOf })
await brain.relate({ from: researchPaper, to: concept, type: VerbType.Describes })
await brain.relate({ from: institution, to: researchPaper, type: VerbType.Creates, subtype: 'publishes' })

4. Domain Independence

The same types work across domains:

Science:

const moleculeId = await brain.add({ data: 'H2O', type: NounType.Substance, metadata: { category: 'molecule' } })
const processId = await brain.add({ data: 'Photosynthesis', type: NounType.Process })
await brain.relate({ from: moleculeId, to: processId, type: VerbType.ParticipatesIn })

Business:

const metricId = await brain.add({ data: 'Q3 Revenue', type: NounType.Measurement, metadata: { value: 10_000_000 } })
const teamId = await brain.add({ data: 'Sales Team', type: NounType.Organization })
await brain.relate({ from: teamId, to: metricId, type: VerbType.RelatedTo, subtype: 'achieves' })

Social:

const personId = await brain.add({ data: 'John', type: NounType.Person })
const groupId = await brain.add({ data: 'Community Group', type: NounType.SocialGroup })
await brain.relate({ from: personId, to: groupId, type: VerbType.MemberOf })

5. Temporal Coverage

Time lives in edge metadata, so past, present, and future all fit:

// Past
await brain.relate({
  from: personId,
  to: companyId,
  type: VerbType.MemberOf,
  subtype: 'past-employment',
  metadata: { from: '2010', to: '2020' }
})

// Present
await brain.relate({
  from: personId,
  to: projectId,
  type: VerbType.ParticipatesIn,
  subtype: 'manager',
  metadata: { since: '2024-01-01' }
})

// Future
await brain.relate({
  from: eventId,
  to: venueId,
  type: VerbType.LocatedAt,
  metadata: { scheduledFor: '2025-06-15' }
})

6. Hierarchical Representation

Every level of abstraction fits:

// Micro level
await brain.add({ data: 'Electron', type: NounType.Thing, metadata: { scale: 'quantum' } })

// Macro level
await brain.add({ data: 'Solar System', type: NounType.Location, metadata: { scale: 'astronomical' } })

// Abstract level
await brain.add({ data: 'Justice', type: NounType.Concept, metadata: { domain: 'philosophy' } })

Extensibility

While the core types cover most domains, you extend with subtype (and metadata) — never a schema migration:

// Extend Person for the medical domain
await brain.add({
  data: 'Patient #12345',
  type: NounType.Person,
  subtype: 'patient',
  metadata: { medicalRecord: 'MR-12345' }
})

// Extend Document for the legal domain
await brain.add({
  data: 'Contract ABC',
  type: NounType.Document,
  subtype: 'contract',
  metadata: { jurisdiction: 'California' }
})

// Extend a verb with a domain-specific subtype + billing metadata
await brain.relate({
  from: lawyerId,
  to: contractId,
  type: VerbType.ParticipatesIn,
  subtype: 'negotiator',
  metadata: { billableHours: 10 }
})

How the Taxonomy Stays Complete

The noun-verb model is designed to represent any knowledge that can be expressed as entities and relations:

1. Storage: Any data can be stored as nouns

2. Relational: Any relationship can be expressed as verbs

3. Property: Open-ended metadata captures all attributes

4. Graph: Multi-hop traversals express arbitrary complexity

5. Temporal: Date metadata handles all temporal aspects

6. Semantic: Vector embeddings capture meaning and similarity

The Composition Formula

Expressiveness = (42 nouns × 127 verbs) × metadata × graph depth
              = 5,334 base combinations × open-ended refinement

That composition lets Brainy represent:

• Scientific Knowledge: From quantum physics to molecular biology

• Business Data: From transactions to supply chains

• Social Graphs: From friendships to organizational hierarchies

• Historical Records: From events to archaeological findings

• Creative Works: From media metadata to story relationships

• Technical Systems: From software architecture to network topology

• Personal Information: From memories to preferences

Real-World Proof: Unmappable Becomes Mappable

Even the most complex scenarios map naturally:

// String Theory — high-dimensional physics
const braneId = await brain.add({
  data: 'D3-Brane',
  type: NounType.Concept,
  metadata: { dimensions: 11, vibrationalModes: ['0,1', '1,0', '2,1'] }
})

// Consciousness — the "hard problem" of philosophy
const qualiaId = await brain.add({
  data: 'Red Qualia',
  type: NounType.Concept,
  subtype: 'phenomenal-experience',
  metadata: { ineffable: true }
})

// Causal paradoxes
const futureEvent = await brain.add({
  data: 'Future Effect',
  type: NounType.Event,
  metadata: { temporalPosition: 'future' }
})
const pastCause = await brain.add({
  data: 'Past Cause',
  type: NounType.Event,
  metadata: { temporalPosition: 'past' }
})
await brain.relate({
  from: futureEvent,
  to: pastCause,
  type: VerbType.Causes,
  metadata: { paradoxType: 'bootstrap' }
})

If it exists, thinks, happens, or can be imagined — Brainy can model it.

Migration from Traditional Models

From Relational (SQL)

// Instead of JOIN queries:
// SELECT * FROM users JOIN orders ON users.id = orders.user_id

// Use noun-verb relationships
const userId = await brain.add({ data: 'User', type: NounType.Person, metadata: { email: 'u@example.com' } })
const orderId = await brain.add({ data: 'Order #1', type: NounType.Event, subtype: 'order' })
await brain.relate({ from: userId, to: orderId, type: VerbType.Creates, subtype: 'placed' })

// Query naturally via the graph
const userOrders = await brain.find({
  type: NounType.Event,
  connected: { from: userId, via: VerbType.Creates }
})

From Document (NoSQL)

// Instead of embedded documents: { user: { orders: [...] } }

// Use explicit relationships
const userId = await brain.add({ data: 'User', type: NounType.Person })
for (const order of orders) {
  const orderId = await brain.add({ data: order.summary, type: NounType.Event, subtype: 'order' })
  await brain.relate({ from: userId, to: orderId, type: VerbType.Creates, subtype: 'placed' })
}

From Graph Databases

// Similar to a graph database, with added benefits:
// 1. Automatic vector embeddings for similarity
// 2. Natural language querying
// 3. Unified with metadata filtering

// Vector + graph in one query
const results = await brain.find({ query: 'users who bought similar products' })

Conclusion

The Noun-Verb Taxonomy gives Brainy a natural, flexible, and powerful way to model any domain. By thinking in terms of entities (42 NounTypes) and their relationships (127 VerbTypes) — refined with subtype and metadata — you can build everything from simple data stores to complex knowledge graphs while keeping code clear and queries simple.

See Also

• Triple Intelligence

• Subtypes & Facets

• The Find System

• API Reference