Vision

Start with the overview, then move into the lenses for AI, SaaS, operating roles, and architecture context.

Vision Overview Cohesive & AI Cohesive & SaaS Cohesive Perspectives Cohesive in Context

Vision

Cohesive in Context

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 represents the useful concept in semantic source artifacts and accumulates it into the 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?

The correspondences below describe the intended semantic interpretation and possible realization strategies. They do not imply that every mapping is currently implemented, mechanically derivable, or portable across every target. A concrete compiler should report whether a mapping is verified, derived under conditions, test-backed, declared by an adapter, unsupported, or still unknown.

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.

Repository

Useful Idea: Hide persistence mechanics behind collection-like access.
Cohesive Interpretation: Repositories can be one storage adapter shape for loading, saving, querying, and versioning entities.
What Cohesive Avoids: Creating generic repositories that obscure actual query, consistency, and transaction requirements.

Unit of Work

Useful Idea: Commit a coordinated set of persistence changes together.
Cohesive Interpretation: A host can run transitions inside explicit transactional scopes when the storage backend supports it.
What Cohesive Avoids: Assuming a database transaction can also roll back messages, emails, payment calls, or search index writes.

SQL / Relational Algebra

Useful Idea: Use declarative joins, filters, grouping, and projections over structured data.
Cohesive Interpretation: Relations can lower to SQL queries, views, and materialized projections when the backend capabilities fit.
What Cohesive Avoids: Embedding domain rules only in ad hoc SQL strings or report queries.

Materialized Views

Useful Idea: Precompute read models for query performance and shape fit.
Cohesive Interpretation: Relations can define projections that are maintained synchronously or asynchronously.
What Cohesive Avoids: Duplicating read-model logic in background jobs without a declared relation to source state.

CQRS

Useful Idea: Separate command-side mutation from query-side read models.
Cohesive Interpretation: Entity transitions model command semantics; Relations and Storage projections model query semantics.
What Cohesive Avoids: Splitting every feature into separate command and query stacks when the asymmetry is not meaningful.

Event Sourcing

Useful Idea: Persist state changes as an append-only history and reconstitute state by replay.
Cohesive Interpretation: Transitions can emit durable events and entities can be backed by event streams where history matters.
What Cohesive Avoids: Forcing all state to be event-sourced when current-state persistence is enough.

Outbox

Useful Idea: Write domain state and integration messages in one atomic boundary.
Cohesive Interpretation: A transition can record committed effects for reliable asynchronous dispatch through Storage and Infra bindings.
What Cohesive Avoids: Sprinkling message-publish calls inside request handlers and hoping dual writes do not fail.

Optimistic Concurrency

Useful Idea: Detect write conflicts through versions, ETags, or expected sequence numbers.
Cohesive Interpretation: Storage adapters can enforce transition preconditions against explicit versions and conflict policies.
What Cohesive Avoids: Hiding conflict behavior inside persistence exceptions with no semantic meaning.

MVCC

Useful Idea: Let readers and writers work over versioned snapshots.
Cohesive Interpretation: Cohesive can rely on MVCC-backed storage while keeping transition and isolation requirements explicit.
What Cohesive Avoids: Mistaking a database implementation detail for the domain's consistency model.

Transaction Isolation Levels

Useful Idea: Choose what concurrent transactions are allowed to observe.
Cohesive Interpretation: Hosts can bind transitions to isolation settings based on read/write sets and invariant risk.
What Cohesive Avoids: Defaulting every operation to one isolation level without understanding the semantic consequence.

Pattern / Concept	Useful Idea	Cohesive Interpretation	What Cohesive Avoids
CRUD	Store and update current state directly.	A Cohesive transition can compile to a current-state update when the write is simple and transactionally local.	Treating CRUD screens and tables as the domain model.
ORM	Map object or shape state to persistence records.	Storage adapters can bind entity observations to ORM-backed persistence while transition semantics remain independent.	Letting ORM navigation properties, lazy loading, or schema constraints define business behavior.
Repository	Hide persistence mechanics behind collection-like access.	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.

Formal analysis applies to projections whose vocabulary and state space support the relevant method. A restricted relational or monotonic fragment may permit a derived coordination result; a broader workflow or escape hatch may instead produce conditions, proof obligations, declared assumptions, or an unknown result. Sharing a graph does not make every property uniformly decidable.

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 requirements explicit, then compares candidate realizations and reports what each preserves, assumes, weakens, or cannot currently establish.