Cohesive defines a semantic model for entities, transitions, processes, relations, and host execution. Cohesive is not another framework, but a semantic layer that can be hosted on many frameworks and implemented through many architectural styles, while keeping state changes, derivations, and workflows explicit and analyzable.

The following reference maps that model to widely used architectural patterns, paradigms, and frameworks.

Truncated Reference
Expanded Reference
Architectural Patterns & Modeling
Execution & Messaging Frameworks
Data Access & Transaction Semantics
Distributed Systems & Data Architecture
Programming Paradigms
UI & Presentation Patterns
Formal Methods & Verification
AI & Advanced Systems
References

Truncated Reference

Below are the core concepts referenced throughout this page.

Pattern / Concept	Relationship to Cohesive
Domain-Driven Design (DDD)	Entities define invariant-preserving consistency boundaries comparable to aggregates.
CQRS	Transitions model command semantics; relations model query semantics.
Event Sourcing	Transitions may emit durable events; projections can rebuild from streams.
Hexagonal Architecture	Host and adapters isolate semantic model from infrastructure.
Saga Pattern	Processes coordinate multi-entity workflows with optional durability.
Temporal / Durable Task	Processes may execute atop durable orchestration engines.
Actor Model (Orleans)	Entities and processes can execute within actor-based runtimes.
ORM	State models can bind to relational storage through adapters.
RDBMS / SQL	Relations may compile to SQL; transitions may execute within database transactions.
Optimistic Concurrency	Version-based conflict detection enforced at the storage layer.
Transaction Isolation Levels	Concurrency guarantees selected at host/storage configuration.
Event-Driven Architecture	Transition events may drive projections and downstream processes.
Materialized Views	Relations maintain asynchronously updated read models.
Data-Oriented Design (SoA / ECS)	State may compile to columnar runtime layouts without altering semantic definitions.
State Machines	Transitions define explicit state progression.
Petri Nets	Processes provide structured coordination comparable to formal concurrent transition systems.
TLA+	State models and transitions provide structured artifacts suitable for formal reasoning.
MVC / MVVM	Presentation adapters bind structured relations to UI surfaces.
ML Pipelines	Processes can orchestrate training/inference workflows with explicit state integration.
ONNX	Inference engines can be integrated as effect handlers with typed transition inputs.

Expanded Reference

Architectural Patterns & Modeling

Pattern / Concept	Primary Emphasis	Relationship to Cohesive
Aggregate Root	Consistency boundary in DDD	Entities define invariant-preserving transition boundaries comparable to aggregate roots.
Anti-Corruption Layer	Boundary translation between systems	Adapters and relations can serve as translation layers between external schemas and internal state models.
Bounded Context	Explicit domain boundary	Cohesive models can define explicit semantic partitions aligned with bounded contexts.
Clean Architecture	Dependency direction toward core	Entities, transitions, and processes form the inner semantic core.
CQRS	Separation of command and query models	Transitions model command semantics; relations/projections model query semantics.
Decider (Decision Model)	Pure command-to-event decision logic	Cohesive transitions correspond to explicit decision points; effects and persistence occur outside the decision semantics via host/adapters.
Domain-Driven Design (DDD)	Aggregates, invariants, bounded contexts	Entities correspond to aggregates; transitions formalize invariant-preserving state changes.
Event Sourcing	Append-only event log	Transitions may emit durable events; projections can rebuild from streams; event sourcing remains optional.
Event Storming	Collaborative domain discovery	Entities, transitions, and events map directly from storming artifacts.
Hexagonal Architecture	Domain isolated from infrastructure	Cohesive Host + adapters separate semantic model from infrastructure concerns.
Layered Architecture	Separation of concerns across tiers	Cohesive defines a semantic core (entities, transitions, processes) that can be hosted within layered systems.
Microservices	Independently deployable services	Processes and model boundaries can define service partitions independent of deployment topology.
Ports & Adapters	Explicit boundary interfaces	Storage, messaging, and UI bind to the semantic model through adapters.
SOLID	Class-level design discipline	Transitions and processes structure responsibility and dependency boundaries at system level.
Specification Pattern	Declarative business rule definition	Relations and transition guards provide declarative rule definitions.
Transaction Script	Procedural orchestration of business logic	Transitions formalize state changes that might otherwise be implemented as transaction scripts.

Execution & Messaging Frameworks

Framework	Primary Emphasis	Relationship to Cohesive
Akka	Actor-based distributed runtime	Cohesive entities can execute on actor systems while retaining explicit transition semantics.
Axon Framework	CQRS + Event Sourcing (JVM)	Entities and transitions parallel aggregates and command handlers; event sourcing remains optional.
Azure Durable Task	Durable orchestration runtime	Processes can run on durable task hosts while preserving semantic definitions.
MassTransit	Distributed messaging abstraction	Effect requests and domain events can publish through bus adapters.
MediatR	In-process request/response dispatch	Transitions can be dispatched through mediator-style pipelines without altering semantics.
NServiceBus	Message-driven architecture, sagas	Processes can execute over message buses; transitions define domain semantics independent of transport.
Orleans	Virtual actor runtime	Entities and processes can execute within actor-based hosting environments.
Saga Pattern	Long-running compensating workflows	Cohesive processes coordinate multi-entity workflows with optional durability and compensation logic.
Temporal	Durable workflow orchestration	Processes may execute atop durable orchestration engines.

Data Access & Transaction Semantics

Pattern / Concept	Primary Emphasis	Relationship to Cohesive
AutoMapper	Object-object mapping	Relations formalize semantic transformations rather than implicit DTO mapping.
Change Data Capture	Incremental state propagation	Projection runners may subscribe to change feeds to maintain derived models.
Dapper	Lightweight SQL access	Storage adapters can integrate direct SQL access while preserving transition semantics.
Entity Framework	ORM for relational databases	State models may bind to EF-backed persistence via adapters.
Eventual Consistency	Relaxed cross-boundary consistency model	Cohesive projections and processes can operate under eventual consistency guarantees.
Mapster	Compile-time object mapping	Relations can compile deterministic transformation logic for transport and indexing.
Materialized Views	Derived read models	Relations and projection runners maintain asynchronously updated read models.
Multi-Version Concurrency Control (MVCC)	Concurrent versioned state management	Underlying storage engines may use MVCC without affecting semantic transition definitions.
Optimistic Concurrency	Version-based conflict detection	Version checks or ETag semantics can be enforced at the storage adapter level.
ORM (Object–Relational Mapping)	Mapping object graphs to relational tables	Cohesive state models can bind to relational storage through ORM adapters; transition semantics remain independent of persistence strategy.
RDBMS	ACID-compliant relational persistence	Host configuration may execute transitions within database transactions while keeping state and transition semantics explicit.
Repository	Collection-like abstraction over persistence	Storage bindings can expose entity persistence through repository-style adapters.
Snapshotting	Periodic materialization of state	Entities backed by event streams may snapshot without altering transition definitions.
SQL	Declarative relational algebra over structured data	Cohesive relations may compile into SQL projections and joins without exposing domain logic to storage-specific constructs.
Transaction Isolation Levels	Concurrency visibility guarantees (Read Comitted, Repeatable Read, Serializable, etc.)	Cohesive Host configures isolation guarantees at the persistence layer; transition semantics remain explicit while concurrency behavior is defined by storage configuration.
Two-Phase Commit (2PC)	Distributed atomic commit	Multi-system coordination strategy (2PC vs saga) is selected at the host/infrastructure layer.
Unit of Work	Coordinated persistence boundary	Host can execute transitions within transactional scopes (RDBMS, event store, document DB).

Distributed Systems & Data Architecture

Concept	Primary Emphasis	Relationship to Cohesive
API-First Design	Contract-driven APIs	Presentation adapters expose transitions and relations as stable endpoints.
CAP Theorem	Tradeoff between consistency, availability, partition tolerance	Cohesive Host selection determines tradeoff behavior; semantic transitions remain explicit.
Consensus (Raft / Paxos)	Agreement across distributed nodes	Underlying storage or runtime may rely on consensus protocols while preserving domain semantics.
Data Mesh	Domain-oriented data ownership	Bounded semantic models align with domain-owned data products.
ETL / Reverse ETL	Data transformation pipelines	Projections can feed analytical and operational systems.
Event-Driven Architecture	Reactive messaging	Transition events may drive projections and downstream processes.
Gossip Protocols	Distributed state dissemination	Cohesive state may propagate across nodes using gossip-based substrates.
GraphQL	Flexible query surfaces	Relations may compile into GraphQL schemas.
gRPC	Strongly typed service transport	Transitions and relations can be surfaced via typed RPC adapters.
OLTP / OLAP	Operational transactions vs analytical aggregation and reporting	Cohesive governs OLTP semantics (entities, transitions, invariants). OLAP systems consume derived projections and exports without contaminating transactional state logic.
PACELC	Latency vs consistency tradeoff	Infrastructure configuration determines consistency/latency balance.
RDMA (Remote Direct Memory Access)	Low-latency direct memory access across nodes	Cohesive execution semantics are independent of transport; high-performance runtimes may leverage RDMA-enabled infrastructure while preserving explicit entity and transition semantics.
Redux	Predictable frontend state transitions	Transition semantics parallel explicit state mutation models on the client side.
Sagas	Long-running distributed coordination	Processes coordinate multi-entity workflows with optional durability.
Streaming Platforms (Kafka / Event Hubs)	Ordered event streams	Domain events can publish to streaming infrastructure.

Programming Paradigms

Paradigm	Primary Emphasis	Relationship to Cohesive
Actor Model	Isolated state + message passing	Entities and processes can execute atop actor runtimes.
CRDTs	Convergent distributed state	State models may incorporate convergent data structures when required.
Data-Oriented Design (SoA / ECS-style storage)	Compact, cache-friendly runtime representation using columns indexed by entity IDs	Cohesive state models can compile to SoA/columnar layouts for efficient in-memory execution and transport, while preserving semantic field and transition definitions.
Datalog	Stratified rule-based relational inference	Cohesive relations may express derived views comparable to Datalog rules, while execution remains integrated with state transitions.
Declarative Programming	Specification of what rather than how	Cohesive transitions and relations describe desired state evolution declaratively.
Functional Programming	Pure transformations, immutability	Transitions model deterministic state changes; effects expressed explicitly.
Object-Oriented Programming	Encapsulation, polymorphism	Entities encapsulate state and invariants.
Reactive Programming	Asynchronous data flow propagation	Transition events and projections can integrate with reactive streams.

UI & Presentation Patterns

Pattern / Concept	Primary Emphasis	Relationship to Cohesive
MVC (Model–View–Controller)	Separation of model, view, and control logic	Cohesive entities and relations define the model; presentation adapters implement view/controller bindings.
MVVM	Declarative UI binding to observable state	Relations can provide structured view models; transitions act as explicit command handlers.
Redux / Predictable State Containers	Explicit state transitions on the client	Transition semantics parallel client-side state reducers; projections can generate UI-facing state slices.
Component-Based UI	Composable UI elements	Relations can define structured data surfaces consumed by UI components.
REST	Resource-oriented HTTP interfaces	Transitions and relations can be exposed via RESTful adapters without embedding domain logic in controllers.
GraphQL	Declarative client-driven queries	Relations may compile into GraphQL schemas, preserving domain semantics while allowing flexible query shapes.
Hypermedia (HATEOAS)	State-driven navigation via links	Transitions can be surfaced as discoverable actions derived from current entity state.
BFF (Backend for Frontend)	UI-specific aggregation layer	Relations can materialize view-specific projections without duplicating domain logic.

Formal Methods & Verification

Concept	Primary Emphasis	Relationship to Cohesive
Bigraphs (Milner)	Formal model combining connectivity and spatial containment	Cohesive processes coordinate entity state transitions across explicit boundaries; bigraph theory provides a formal lens for reasoning about interaction and locality.
Jepsen-style Testing	Consistency validation under failure	Explicit invariants enable systematic resilience testing.
Petri Nets	Formal model of concurrent state transitions using places and tokens	Cohesive processes coordinate multi-entity transitions with explicit state and effect semantics; Petri net concepts provide a formal lens for reasoning about concurrency and reachability.
Process Calculus	Concurrent process semantics	Processes coordinate entity interactions with explicit effect modeling.
State Machines	Explicit state evolution	Transitions define formal state progression.
TLA+	Mathematical system specification	State models and transitions provide structured artifacts suitable for formal reasoning.

AI & Advanced Systems

Concept / System	Primary Emphasis	Relationship to Cohesive
ML Pipelines	Training, evaluation, deployment lifecycle	Projections can emit training datasets; processes can coordinate training/inference workflows and feed results back as explicit transitions.
Online Inference	Low-latency model serving	Effect handlers can invoke inference services; outputs re-enter the system as typed transition inputs.
Batch Scoring	Offline inference over large datasets	Processes can orchestrate batch jobs; results materialize into state updates and downstream projections.
ONNX	Portable model interchange for inference	Host can integrate ONNX runtimes as effect handlers; inference outputs are recorded as explicit domain state changes.
Feature Store	Reusable features for training/serving consistency	Relations/projections can define feature extraction as durable, versioned artifacts consumed by training and serving.
Vector Database	Similarity search over embeddings	Adapters can bind vector indexes; relations can define retrieval semantics and join results back into domain views.
Embeddings	Numeric representations for retrieval and matching	Projections can compute embeddings from domain events/state; processes can schedule re-embedding and backfills.
RAG (Retrieval-Augmented Generation)	Grounding generation on retrieved context	Relations can define retrieval views; processes can orchestrate retrieval + generation + persistence of outputs as domain facts.
LLM Tool Use / Function Calling	Model-driven orchestration over tools	Cohesive processes can expose constrained operations as tools; results are captured as transitions rather than ad-hoc side effects.
MCP (Model Context Protocol)	Standardized model–tool interaction protocol	Cohesive relations can define structured context surfaces for models; processes coordinate model-invoked actions and persist outcomes as domain state changes.
Model Registry / Versioning	Managing model versions and provenance	Model versions can be treated as part of system state/config; host controls rollout and compatibility policies.
Monitoring & Drift Detection	Quality, performance, and distribution shifts	Projections can emit metrics and audit trails; processes can trigger retraining or rollback via explicit transitions.
Data Lineage	Traceability from inputs to outputs	Transition and projection artifacts provide a natural backbone for lineage and reproducibility.
RDMA	Low-latency inter-node communication substrate	Execution semantics are transport-independent; advanced runtimes may leverage RDMA while preserving entity/transition semantics.