Cohesive defines a semantic system graph for software design. Its building blocks make structure, state change, relations, processes, identity, APIs, presentation, storage, infrastructure, and AI context explicit, then project that graph into the runtimes and architectural patterns that fit.
Core Idea
Cohesive is not a replacement for DDD, CQRS, event sourcing, actors, sagas, workflow engines, relational databases, message buses, REST, GraphQL, UI state patterns, formal methods, or AI orchestration tools.
Each one is a partial view of the same system design space.
The problem is that they often arrive as bundled realization models. A team adopts the useful idea and also inherits naming conventions, directory structures, runtime assumptions, storage choices, operational practices, and social rituals that may not fit the system at hand.
Cohesive puts the useful concept into the semantic system graph before choosing the package it will travel through.
A consistency boundary can become an entity transition boundary without adopting a full DDD program. A command/query split can become transitions plus relations without turning every feature into CQRS. A transition history can be durable where history matters without forcing the whole domain into event sourcing. A workflow can become a Cohesive process without making every operation a heavyweight saga. An actor runtime can host identity-scoped entity or process execution without becoming the domain model.
Cohesive keeps those choices explicit inside one semantic system graph.
The Recurring Pattern
Most architectural concepts can be read as partial views of the same graph:
What system pressure does the concept address?
Which Cohesive building blocks carry that structure?
Which implementation, runtime, or methodology becomes optional?
Modeling methods
System Pressure
Naming domain boundaries, invariants, and responsibilities.
Cohesive Building Blocks
Core, Entities, Machines, Relations, and Processes define shapes, observations, transitions, policies, lifecycle states, and process boundaries.
Optional Package
A fixed design process, aggregate taxonomy, or organization-wide methodology.
Persistence patterns
System Pressure
Choosing how state is stored, reconstructed, and audited.
Cohesive Building Blocks
Storage binds observations, entity state, transition histories, version checks, projections, streams, and backend capabilities.
Optional Package
A single global storage style such as all-CRUD or all-event-sourced systems.
Coordination patterns
System Pressure
Handling work that crosses entities, services, workers, users, and time.
Cohesive Building Blocks
Processes and entity effects define waits, retries, compensation, child flows, committed effects, and execution state.
Optional Package
A mandatory workflow engine, broker topology, or distributed-systems pattern everywhere.
Interface patterns
System Pressure
Exposing stable APIs and UI surfaces over changing internal systems.
Cohesive Building Blocks
API and Presentation project operations, relation surfaces, actions, forms, scopes, generated clients, and UI contracts.
Optional Package
Controller-heavy applications, UI-specific duplicated logic, or one transport as the source of truth.
Verification and AI patterns
System Pressure
Reasoning about system behavior, generated artifacts, and model-driven operations.
Cohesive Building Blocks
Core, Relations, Processes, Identity, and AI expose invariants, traceable transitions, retrieval surfaces, constrained tools, and generated contexts.
Optional Package
Separate verification models or AI glue code disconnected from runtime semantics.
Concept Type
System Pressure
Cohesive Building Blocks
Optional Package
Modeling methods
Naming domain boundaries, invariants, and responsibilities.
Core, Entities, Machines, Relations, and Processes define shapes, observations, transitions, policies, lifecycle states, and process boundaries.
A fixed design process, aggregate taxonomy, or organization-wide methodology.
Persistence patterns
Choosing how state is stored, reconstructed, and audited.
Storage binds observations, entity state, transition histories, version checks, projections, streams, and backend capabilities.
A single global storage style such as all-CRUD or all-event-sourced systems.
Coordination patterns
Handling work that crosses entities, services, workers, users, and time.
Processes and entity effects define waits, retries, compensation, child flows, committed effects, and execution state.
A mandatory workflow engine, broker topology, or distributed-systems pattern everywhere.
Interface patterns
Exposing stable APIs and UI surfaces over changing internal systems.
API and Presentation project operations, relation surfaces, actions, forms, scopes, generated clients, and UI contracts.
Controller-heavy applications, UI-specific duplicated logic, or one transport as the source of truth.
Verification and AI patterns
Reasoning about system behavior, generated artifacts, and model-driven operations.
Core, Relations, Processes, Identity, and AI expose invariants, traceable transitions, retrieval surfaces, constrained tools, and generated contexts.
Separate verification models or AI glue code disconnected from runtime semantics.
Architectural & Modeling Concepts
These concepts help teams find boundaries, responsibilities, and business meaning. Cohesive treats them as inputs to the semantic system graph rather than as complete architectures by themselves.
Domain-Driven Design
Useful Idea
Use the domain model, ubiquitous language, bounded contexts, and invariants to organize software.
Cohesive Interpretation
Core, Entities, Machines, Relations, and Processes turn domain language into graph artifacts that can be generated, inspected, tested, projected, and hosted.
What Cohesive Avoids
Adopting every DDD ceremony, class style, aggregate rule, and team ritual before the system needs it.
Aggregate Root
Useful Idea
Define a consistency boundary where invariants are protected.
Cohesive Interpretation
A Cohesive entity can own invariant-preserving transitions over a coherent state boundary.
What Cohesive Avoids
Treating every object graph as an aggregate or forcing all consistency decisions into object hierarchy design.
Bounded Context
Useful Idea
Separate meanings that should not be collapsed into one model.
Cohesive Interpretation
The graph can define semantic partitions, relation mappings, and anti-corruption boundaries between contexts.
What Cohesive Avoids
Making service topology, repo layout, or org structure the only expression of context boundaries.
Anti-Corruption Layer
Useful Idea
Translate between external schemas and internal meanings.
Cohesive Interpretation
Relations and adapters can describe transformations between outside contracts and internal graph semantics.
What Cohesive Avoids
Handwritten mapping code scattered through controllers, services, and jobs.
Clean / Hexagonal Architecture
Useful Idea
Keep domain meaning independent from infrastructure.
Cohesive Interpretation
Cohesive separates graph definitions from storage, transport, runtime, infrastructure, and presentation adapters.
What Cohesive Avoids
A rigid ring diagram, folder taxonomy, or framework-specific dependency rule as the architecture itself.
Ports & Adapters
Useful Idea
Bind a stable core to replaceable external mechanisms.
Cohesive Interpretation
Storage, messaging, identity, effects, APIs, presentation surfaces, and infrastructure attach through explicit adapter contracts.
What Cohesive Avoids
Interfaces created only because the pattern says so, with no semantic role in the system model.
Specification Pattern
Useful Idea
Represent business rules as reusable declarative predicates.
Cohesive Interpretation
Transition guards, policies, relation filters, and validation rules can be modeled directly.
What Cohesive Avoids
A parallel rule-object hierarchy detached from the operations that rely on those rules.
Transaction Script
Useful Idea
Keep simple business operations direct and procedural.
Cohesive Interpretation
A Cohesive transition can lower to a simple script when the operation is local, synchronous, and low-risk.
What Cohesive Avoids
Letting scripts become the hidden place where all invariants, side effects, and workflows accumulate.
Microservices
Useful Idea
Deploy and scale independent capabilities behind explicit contracts.
Cohesive Interpretation
Graph boundaries can inform service partitions, but semantic ownership stays independent from deployment topology.
What Cohesive Avoids
Splitting the domain into remote calls before semantic boundaries and consistency needs are understood.
Data Mesh
Useful Idea
Treat domain-owned data products as first-class assets.
Cohesive Interpretation
Relations, projections, lineage, storage capabilities, and ownership boundaries can define data products from the same graph.
What Cohesive Avoids
Separate analytics ownership language disconnected from operational state and transitions.
Pattern / Concept
Useful Idea
Cohesive Interpretation
What Cohesive Avoids
Domain-Driven Design
Use the domain model, ubiquitous language, bounded contexts, and invariants to organize software.
Core, Entities, Machines, Relations, and Processes turn domain language into graph artifacts that can be generated, inspected, tested, projected, and hosted.
Adopting every DDD ceremony, class style, aggregate rule, and team ritual before the system needs it.
Aggregate Root
Define a consistency boundary where invariants are protected.
A Cohesive entity can own invariant-preserving transitions over a coherent state boundary.
Treating every object graph as an aggregate or forcing all consistency decisions into object hierarchy design.
Bounded Context
Separate meanings that should not be collapsed into one model.
The graph can define semantic partitions, relation mappings, and anti-corruption boundaries between contexts.
Making service topology, repo layout, or org structure the only expression of context boundaries.
Anti-Corruption Layer
Translate between external schemas and internal meanings.
Relations and adapters can describe transformations between outside contracts and internal graph semantics.
Handwritten mapping code scattered through controllers, services, and jobs.
Clean / Hexagonal Architecture
Keep domain meaning independent from infrastructure.
Cohesive separates graph definitions from storage, transport, runtime, infrastructure, and presentation adapters.
A rigid ring diagram, folder taxonomy, or framework-specific dependency rule as the architecture itself.
Ports & Adapters
Bind a stable core to replaceable external mechanisms.
Storage, messaging, identity, effects, APIs, presentation surfaces, and infrastructure attach through explicit adapter contracts.
Interfaces created only because the pattern says so, with no semantic role in the system model.
Specification Pattern
Represent business rules as reusable declarative predicates.
Transition guards, policies, relation filters, and validation rules can be modeled directly.
A parallel rule-object hierarchy detached from the operations that rely on those rules.
Transaction Script
Keep simple business operations direct and procedural.
A Cohesive transition can lower to a simple script when the operation is local, synchronous, and low-risk.
Letting scripts become the hidden place where all invariants, side effects, and workflows accumulate.
Microservices
Deploy and scale independent capabilities behind explicit contracts.
Graph boundaries can inform service partitions, but semantic ownership stays independent from deployment topology.
Splitting the domain into remote calls before semantic boundaries and consistency needs are understood.
Data Mesh
Treat domain-owned data products as first-class assets.
Relations, projections, lineage, storage capabilities, and ownership boundaries can define data products from the same graph.
Separate analytics ownership language disconnected from operational state and transitions.
Data & Persistence Concepts
Persistence patterns answer realization questions over the graph: what is authoritative, what can be derived, how history is represented, and how concurrency is controlled. Cohesive keeps those questions explicit per shape, entity, transition, relation, storage binding, and host.
CRUD
Useful Idea
Store and update current state directly.
Cohesive Interpretation
A Cohesive transition can compile to a current-state update when the write is simple and transactionally local.
What Cohesive Avoids
Treating CRUD screens and tables as the domain model.
ORM
Useful Idea
Map object or shape state to persistence records.
Cohesive Interpretation
Storage adapters can bind entity observations to ORM-backed persistence while transition semantics remain independent.
What Cohesive Avoids
Letting ORM navigation properties, lazy loading, or schema constraints define business behavior.
Repositories can be one storage adapter shape for loading, saving, querying, and versioning entities.
Creating generic repositories that obscure actual query, consistency, and transaction requirements.
Unit of Work
Commit a coordinated set of persistence changes together.
A host can run transitions inside explicit transactional scopes when the storage backend supports it.
Assuming a database transaction can also roll back messages, emails, payment calls, or search index writes.
SQL / Relational Algebra
Use declarative joins, filters, grouping, and projections over structured data.
Relations can lower to SQL queries, views, and materialized projections when the backend capabilities fit.
Embedding domain rules only in ad hoc SQL strings or report queries.
Materialized Views
Precompute read models for query performance and shape fit.
Relations can define projections that are maintained synchronously or asynchronously.
Duplicating read-model logic in background jobs without a declared relation to source state.
CQRS
Separate command-side mutation from query-side read models.
Entity transitions model command semantics; Relations and Storage projections model query semantics.
Splitting every feature into separate command and query stacks when the asymmetry is not meaningful.
Event Sourcing
Persist state changes as an append-only history and reconstitute state by replay.
Transitions can emit durable events and entities can be backed by event streams where history matters.
Forcing all state to be event-sourced when current-state persistence is enough.
Outbox
Write domain state and integration messages in one atomic boundary.
A transition can record committed effects for reliable asynchronous dispatch through Storage and Infra bindings.
Sprinkling message-publish calls inside request handlers and hoping dual writes do not fail.
Optimistic Concurrency
Detect write conflicts through versions, ETags, or expected sequence numbers.
Storage adapters can enforce transition preconditions against explicit versions and conflict policies.
Hiding conflict behavior inside persistence exceptions with no semantic meaning.
MVCC
Let readers and writers work over versioned snapshots.
Cohesive can rely on MVCC-backed storage while keeping transition and isolation requirements explicit.
Mistaking a database implementation detail for the domain's consistency model.
Transaction Isolation Levels
Choose what concurrent transactions are allowed to observe.
Hosts can bind transitions to isolation settings based on read/write sets and invariant risk.
Defaulting every operation to one isolation level without understanding the semantic consequence.
Execution & Coordination Concepts
Coordination concepts answer where work runs, how messages move, how failure is handled, and how operations continue across time. Cohesive.Processes and entity effects make the coordination model explicit before choosing a runtime.
Actor Model
Useful Idea
Use identity-scoped state, mailboxes, and message ordering to control concurrency.
Cohesive Interpretation
Entities and Processes can execute on actor runtimes while preserving explicit transition and effect semantics.
What Cohesive Avoids
Letting actor classes become the only domain model or using actors for every coordination problem.
Orleans
Useful Idea
Virtual actors with placement, activation, and state providers.
Cohesive Interpretation
Cohesive entities can be hosted as grains where identity-local execution is a good fit.
What Cohesive Avoids
Binding domain semantics to Orleans-specific lifecycle and hosting decisions.
Akka
Useful Idea
Concurrent actors, supervision, clustering, and message-driven systems.
Cohesive Interpretation
Cohesive processes and entities can lower to actor behaviors while keeping effects and transitions inspectable.
What Cohesive Avoids
Encoding all business workflow as actor message choreography with no higher-level process model.
Saga Pattern
Useful Idea
Coordinate distributed steps with compensating actions.
Cohesive Interpretation
A Cohesive process can define forward steps, waits, retries, timeouts, and compensation paths.
What Cohesive Avoids
Turning every multi-step operation into a saga when a local transition or outbox is sufficient.
Durable Execution
Useful Idea
Persist workflow history, timers, retries, and activity results so work can resume after failure.
Cohesive Interpretation
Processes can run on durable workflow hosts without making the host API the source of truth.
What Cohesive Avoids
Writing business definitions directly in engine-specific workflow code that cannot be reused elsewhere.
Temporal / Durable Task
Useful Idea
Provide durable orchestration runtime for long-running workflows.
Cohesive Interpretation
A process model can be interpreted by Temporal, Durable Task, or a custom executor as deployment needs change.
What Cohesive Avoids
Choosing the workflow runtime before deciding which operations actually need durable orchestration.
MediatR
Useful Idea
Route in-process requests through handlers and pipeline behaviors.
Cohesive Interpretation
Transitions can be dispatched through mediator-style pipelines while preserving the same semantic operation.
What Cohesive Avoids
Making handler dispatch the architecture instead of a runtime convenience.
NServiceBus / MassTransit
Useful Idea
Coordinate distributed messaging, consumers, retries, and sagas.
Cohesive Interpretation
Domain events, effect requests, and processes can publish through bus adapters.
What Cohesive Avoids
Letting broker messages define business meaning without explicit entities, transitions, and relations.
Event-Driven Architecture
Useful Idea
Use events to decouple producers, consumers, and derived work.
Cohesive Interpretation
Transition events can drive projections, downstream processes, integrations, and audit trails.
What Cohesive Avoids
Event soup: topics and handlers with unclear authority, ownership, ordering, or replay semantics.
Streaming Platforms
Useful Idea
Retain ordered logs for high-throughput event distribution and replay.
Cohesive Interpretation
Transition events, observation streams, and projections can bind to Kafka, Event Hubs, or equivalent streams.
What Cohesive Avoids
Treating the stream as the domain model rather than as one realization layer.
Pub/Sub
Useful Idea
Coordinate indirectly through topics and subscriptions.
Cohesive Interpretation
Effects and events can publish through adapters while consumers map back to declared processes or transitions.
What Cohesive Avoids
Invisible coupling through topic names, payload drift, and undocumented consumer behavior.
Two-Phase Commit
Useful Idea
Coordinate atomic commit across participants when the environment supports it.
Cohesive Interpretation
Host configuration can select 2PC, outbox, saga, or compensating process based on participant capabilities.
What Cohesive Avoids
Assuming distributed atomicity is available or desirable across every boundary.
Pattern / Framework
Useful Idea
Cohesive Interpretation
What Cohesive Avoids
Actor Model
Use identity-scoped state, mailboxes, and message ordering to control concurrency.
Entities and Processes can execute on actor runtimes while preserving explicit transition and effect semantics.
Letting actor classes become the only domain model or using actors for every coordination problem.
Orleans
Virtual actors with placement, activation, and state providers.
Cohesive entities can be hosted as grains where identity-local execution is a good fit.
Binding domain semantics to Orleans-specific lifecycle and hosting decisions.
Akka
Concurrent actors, supervision, clustering, and message-driven systems.
Cohesive processes and entities can lower to actor behaviors while keeping effects and transitions inspectable.
Encoding all business workflow as actor message choreography with no higher-level process model.
Saga Pattern
Coordinate distributed steps with compensating actions.
A Cohesive process can define forward steps, waits, retries, timeouts, and compensation paths.
Turning every multi-step operation into a saga when a local transition or outbox is sufficient.
Durable Execution
Persist workflow history, timers, retries, and activity results so work can resume after failure.
Processes can run on durable workflow hosts without making the host API the source of truth.
Writing business definitions directly in engine-specific workflow code that cannot be reused elsewhere.
Temporal / Durable Task
Provide durable orchestration runtime for long-running workflows.
A process model can be interpreted by Temporal, Durable Task, or a custom executor as deployment needs change.
Choosing the workflow runtime before deciding which operations actually need durable orchestration.
MediatR
Route in-process requests through handlers and pipeline behaviors.
Transitions can be dispatched through mediator-style pipelines while preserving the same semantic operation.
Making handler dispatch the architecture instead of a runtime convenience.
NServiceBus / MassTransit
Coordinate distributed messaging, consumers, retries, and sagas.
Domain events, effect requests, and processes can publish through bus adapters.
Letting broker messages define business meaning without explicit entities, transitions, and relations.
Event-Driven Architecture
Use events to decouple producers, consumers, and derived work.
Transition events can drive projections, downstream processes, integrations, and audit trails.
Event soup: topics and handlers with unclear authority, ownership, ordering, or replay semantics.
Streaming Platforms
Retain ordered logs for high-throughput event distribution and replay.
Transition events, observation streams, and projections can bind to Kafka, Event Hubs, or equivalent streams.
Treating the stream as the domain model rather than as one realization layer.
Pub/Sub
Coordinate indirectly through topics and subscriptions.
Effects and events can publish through adapters while consumers map back to declared processes or transitions.
Invisible coupling through topic names, payload drift, and undocumented consumer behavior.
Two-Phase Commit
Coordinate atomic commit across participants when the environment supports it.
Host configuration can select 2PC, outbox, saga, or compensating process based on participant capabilities.
Assuming distributed atomicity is available or desirable across every boundary.
API & Presentation Concepts
Interface patterns expose graph capabilities to people, clients, and other services. Cohesive.Api and Cohesive.Presentation keep operations, relations, actions, scopes, forms, views, and generated clients connected to the same underlying semantics.
REST
Useful Idea
Expose resource-oriented HTTP interactions with stable contracts.
Cohesive Interpretation
API adapters can surface transitions and relations through REST without embedding domain logic in controllers.
What Cohesive Avoids
Letting URL shape and controller code become the primary system model.
GraphQL
Useful Idea
Let clients query typed data graphs flexibly.
Cohesive Interpretation
Relations can compile into schema fields and resolvers, with transitions exposed as controlled operations.
What Cohesive Avoids
Duplicating authorization, mapping, and business rules in resolver code.
gRPC
Useful Idea
Use strongly typed service calls over efficient transport.
Cohesive Interpretation
Operations, inputs, outputs, and capabilities can project to gRPC contracts.
What Cohesive Avoids
Treating protobuf service shape as the only expression of domain behavior.
API-First Design
Useful Idea
Design external contracts before implementation details harden.
Cohesive Interpretation
API definitions can be generated from semantic operations, relation surfaces, scope policies, and result variants.
What Cohesive Avoids
Separating API documentation from the executable model that must actually honor it.
Backend for Frontend
Useful Idea
Shape backend responses around a particular UI or client experience.
Cohesive Interpretation
Relations and presentation models can define client-specific projections without duplicating domain logic.
What Cohesive Avoids
Ad hoc aggregation services that drift from core state, permissions, and transitions.
MVC
Useful Idea
Separate model, view, and controller responsibilities.
Cohesive Interpretation
Entities and relations define model semantics; presentation adapters bind views and actions to transitions.
What Cohesive Avoids
Controller methods that accumulate validation, authorization, mapping, workflow, and persistence logic.
MVVM
Useful Idea
Represent UI state through view models and commands.
Cohesive Interpretation
Relations can produce view models while transitions become explicit commands/actions.
What Cohesive Avoids
Maintaining a UI-only domain model with duplicated rules and stale action availability.
Redux / Predictable State
Useful Idea
Make state changes explicit through actions and reducers.
Cohesive Interpretation
Cohesive transitions provide a server-side counterpart to explicit state mutation and can feed UI projections.
What Cohesive Avoids
Treating client state containers as the authoritative business system.
Hypermedia / HATEOAS
Useful Idea
Expose valid next actions based on current state.
Cohesive Interpretation
Presentation adapters can derive available actions from entity state, identity, policy, and transition guards.
What Cohesive Avoids
Hand-maintained links and buttons that do not reflect actual domain legality.
Component-Based UI
Useful Idea
Compose screens from reusable interaction units.
Cohesive Interpretation
Presentation models can describe forms, actions, views, data sources, bindings, and generated contracts consumed by components.
What Cohesive Avoids
Components reaching through API layers to reconstruct domain meaning on the client.
Pattern / Concept
Useful Idea
Cohesive Interpretation
What Cohesive Avoids
REST
Expose resource-oriented HTTP interactions with stable contracts.
API adapters can surface transitions and relations through REST without embedding domain logic in controllers.
Letting URL shape and controller code become the primary system model.
GraphQL
Let clients query typed data graphs flexibly.
Relations can compile into schema fields and resolvers, with transitions exposed as controlled operations.
Duplicating authorization, mapping, and business rules in resolver code.
gRPC
Use strongly typed service calls over efficient transport.
Operations, inputs, outputs, and capabilities can project to gRPC contracts.
Treating protobuf service shape as the only expression of domain behavior.
API-First Design
Design external contracts before implementation details harden.
API definitions can be generated from semantic operations, relation surfaces, scope policies, and result variants.
Separating API documentation from the executable model that must actually honor it.
Backend for Frontend
Shape backend responses around a particular UI or client experience.
Relations and presentation models can define client-specific projections without duplicating domain logic.
Ad hoc aggregation services that drift from core state, permissions, and transitions.
MVC
Separate model, view, and controller responsibilities.
Entities and relations define model semantics; presentation adapters bind views and actions to transitions.
Controller methods that accumulate validation, authorization, mapping, workflow, and persistence logic.
MVVM
Represent UI state through view models and commands.
Relations can produce view models while transitions become explicit commands/actions.
Maintaining a UI-only domain model with duplicated rules and stale action availability.
Redux / Predictable State
Make state changes explicit through actions and reducers.
Cohesive transitions provide a server-side counterpart to explicit state mutation and can feed UI projections.
Treating client state containers as the authoritative business system.
Hypermedia / HATEOAS
Expose valid next actions based on current state.
Presentation adapters can derive available actions from entity state, identity, policy, and transition guards.
Hand-maintained links and buttons that do not reflect actual domain legality.
Component-Based UI
Compose screens from reusable interaction units.
Presentation models can describe forms, actions, views, data sources, bindings, and generated contracts consumed by components.
Components reaching through API layers to reconstruct domain meaning on the client.
Formal, AI & Advanced Concepts
Formal methods, AI systems, and performance-oriented patterns benefit from a
precise semantic system graph. Cohesive gives them structured artifacts to
inspect, generate from, or lower into specialized runtimes.
State Machines
Useful Idea
Model legal states and transitions explicitly.
Cohesive Interpretation
Machines and entity transitions can define legal progression, terminal states, guards, and coherence rules.
What Cohesive Avoids
Scattered enums and status checks that do not agree across code paths.
Petri Nets
Useful Idea
Reason about concurrent transitions, places, tokens, and reachability.
Cohesive Interpretation
Cohesive processes provide structured coordination artifacts that can be analyzed through similar lenses.
What Cohesive Avoids
Requiring teams to author formal Petri net models for everyday application workflows.
TLA+
Useful Idea
Specify and check system behavior mathematically.
Cohesive Interpretation
Entities, transitions, invariants, and process steps can provide source material for formal specifications.
What Cohesive Avoids
A separate spec that diverges from implementation because the runtime model is not explicit.
Jepsen-Style Testing
Useful Idea
Validate distributed consistency claims under failure.
Cohesive Interpretation
Explicit invariants, histories, transitions, and projections give failure tests clear correctness criteria.
What Cohesive Avoids
Testing infrastructure behavior without clear domain-level correctness criteria.
Datalog
Useful Idea
Use declarative rules to infer relations from facts.
Cohesive Interpretation
Cohesive relations can express derived views, joins, constraints, and rule-like projections.
What Cohesive Avoids
Moving operational business behavior into an isolated logic system when integration with transitions is needed.
CRDTs
Useful Idea
Allow distributed state to converge without central coordination.
Cohesive Interpretation
State models can choose convergent data structures where collaboration and partition tolerance require them.
What Cohesive Avoids
Using CRDTs for data that actually needs centralized invariants or legal transition control.
Data-Oriented Design
Useful Idea
Optimize runtime layouts around cache locality, columns, and bulk operations.
Cohesive Interpretation
Cohesive shapes can lower to efficient SoA or columnar representations without changing semantic definitions.
What Cohesive Avoids
Letting performance layout erase field meaning, invariants, and transition rules.
ML Pipelines
Useful Idea
Coordinate data extraction, training, evaluation, deployment, and monitoring.
Cohesive Interpretation
Processes can orchestrate training and inference workflows while relations define datasets and features.
What Cohesive Avoids
A separate ML workflow island disconnected from operational state and business transitions.
Feature Stores
Useful Idea
Share versioned features between training and serving.
Cohesive Interpretation
Relations and projections can define feature extraction as traceable artifacts from domain facts.
What Cohesive Avoids
Feature definitions copied between notebooks, batch jobs, and online services.
Vector Databases
Useful Idea
Index embeddings for similarity search and retrieval.
Cohesive Interpretation
AI and storage adapters can bind vector indexes while Relations define retrieval semantics and joins back to domain views.
What Cohesive Avoids
Treating embeddings as ungoverned side data with no lineage or domain ownership.
RAG
Useful Idea
Ground generated output in retrieved context.
Cohesive Interpretation
Relations can define retrieval surfaces; processes can orchestrate retrieval, generation, review, and persistence.
What Cohesive Avoids
Prompt glue that bypasses permissions, provenance, action legality, and domain state.
MCP / Tool Use
Useful Idea
Expose tools and context to models through structured protocols.
Cohesive Interpretation
Cohesive operations can become constrained tools, and relation surfaces can become model context.
What Cohesive Avoids
AI agents invoking ad hoc functions whose side effects are not captured as transitions.
Concept / System
Useful Idea
Cohesive Interpretation
What Cohesive Avoids
State Machines
Model legal states and transitions explicitly.
Machines and entity transitions can define legal progression, terminal states, guards, and coherence rules.
Scattered enums and status checks that do not agree across code paths.
Petri Nets
Reason about concurrent transitions, places, tokens, and reachability.
Cohesive processes provide structured coordination artifacts that can be analyzed through similar lenses.
Requiring teams to author formal Petri net models for everyday application workflows.
TLA+
Specify and check system behavior mathematically.
Entities, transitions, invariants, and process steps can provide source material for formal specifications.
A separate spec that diverges from implementation because the runtime model is not explicit.
Jepsen-Style Testing
Validate distributed consistency claims under failure.
Explicit invariants, histories, transitions, and projections give failure tests clear correctness criteria.
Testing infrastructure behavior without clear domain-level correctness criteria.
Datalog
Use declarative rules to infer relations from facts.
Cohesive relations can express derived views, joins, constraints, and rule-like projections.
Moving operational business behavior into an isolated logic system when integration with transitions is needed.
CRDTs
Allow distributed state to converge without central coordination.
State models can choose convergent data structures where collaboration and partition tolerance require them.
Using CRDTs for data that actually needs centralized invariants or legal transition control.
Data-Oriented Design
Optimize runtime layouts around cache locality, columns, and bulk operations.
Cohesive shapes can lower to efficient SoA or columnar representations without changing semantic definitions.
Letting performance layout erase field meaning, invariants, and transition rules.
ML Pipelines
Coordinate data extraction, training, evaluation, deployment, and monitoring.
Processes can orchestrate training and inference workflows while relations define datasets and features.
A separate ML workflow island disconnected from operational state and business transitions.
Feature Stores
Share versioned features between training and serving.
Relations and projections can define feature extraction as traceable artifacts from domain facts.
Feature definitions copied between notebooks, batch jobs, and online services.
Vector Databases
Index embeddings for similarity search and retrieval.
AI and storage adapters can bind vector indexes while Relations define retrieval semantics and joins back to domain views.
Treating embeddings as ungoverned side data with no lineage or domain ownership.
RAG
Ground generated output in retrieved context.
Relations can define retrieval surfaces; processes can orchestrate retrieval, generation, review, and persistence.
Prompt glue that bypasses permissions, provenance, action legality, and domain state.
MCP / Tool Use
Expose tools and context to models through structured protocols.
Cohesive operations can become constrained tools, and relation surfaces can become model context.
AI agents invoking ad hoc functions whose side effects are not captured as transitions.
Selection Logic
Cohesive does not erase architecture decisions. It turns them into realization choices over an explicit graph.
A local state update with one consistency boundary
Likely Realization
Current-state persistence, repository, or direct SQL transaction.
Why Cohesive Helps
The entity transition, invariant, and version requirements stay explicit even if the implementation is simple.
Reliable publication after a state change
Likely Realization
Transactional outbox, change feed, or event stream.
Why Cohesive Helps
The emitted event is attached to the transition that made it true.
Audit, replay, or temporal reasoning
Likely Realization
Event-sourced entity or durable transition history.
Why Cohesive Helps
History is selected because it has semantic value, not because the architecture defaults to events.
Identity-scoped ordering and high concurrency
Likely Realization
Actor, grain, or partition-owned executor.
Why Cohesive Helps
The actor is a host strategy for explicit entity and process semantics.
Timers, retries, human waits, or compensation
Likely Realization
Durable process, saga, or workflow engine.
Why Cohesive Helps
The workflow shape is modeled independently from the engine used to run it.
Read shapes that differ from write shapes
Likely Realization
Projection, materialized view, GraphQL resolver, or BFF relation.
Why Cohesive Helps
The relation surface remains connected to source observations, entity state, and transition events.
AI or generated-system interaction
Likely Realization
Tool surfaces, retrieval relations, process orchestration, and audited transitions.
Why Cohesive Helps
Model actions operate through constrained operations, relation surfaces, identity policy, and audited transitions instead of direct side effects.
If The Graph Requires
Likely Realization
Why Cohesive Helps
A local state update with one consistency boundary
Current-state persistence, repository, or direct SQL transaction.
The entity transition, invariant, and version requirements stay explicit even if the implementation is simple.
Reliable publication after a state change
Transactional outbox, change feed, or event stream.
The emitted event is attached to the transition that made it true.
Audit, replay, or temporal reasoning
Event-sourced entity or durable transition history.
History is selected because it has semantic value, not because the architecture defaults to events.
Identity-scoped ordering and high concurrency
Actor, grain, or partition-owned executor.
The actor is a host strategy for explicit entity and process semantics.
Timers, retries, human waits, or compensation
Durable process, saga, or workflow engine.
The workflow shape is modeled independently from the engine used to run it.
Read shapes that differ from write shapes
Projection, materialized view, GraphQL resolver, or BFF relation.
The relation surface remains connected to source observations, entity state, and transition events.
AI or generated-system interaction
Tool surfaces, retrieval relations, process orchestration, and audited transitions.
Model actions operate through constrained operations, relation surfaces, identity policy, and audited transitions instead of direct side effects.
Why This Matters
System design becomes harder when every good idea turns into a package deal.
Teams should be able to borrow the insight behind a pattern without accepting
the entire framework, runtime, vocabulary, and operating model that usually
comes with it. Cohesive gives those insights a common place in the semantic
system graph.
That is the practical position:
Use the consistency boundary from DDD as an entity transition boundary without requiring full DDD adoption.
Use the command/query distinction from CQRS as transitions plus relations without making every feature CQRS-shaped.
Use event history where history matters without event-sourcing everything.
Use actors where identity-local ordering matters without turning actor code into the domain.
Use workflow engines where durability matters without hiding process semantics in engine APIs.
Use AI tool protocols where models need action surfaces without bypassing operations, identity, relations, and audited transitions.
Cohesive makes the underlying graph explicit, then lets the system choose the smallest realization that preserves it.
