Vision

The missing language layer for system design.

Software has mature languages for implementation, but system-level design still lives mostly in prose, diagrams, patterns, and conventions. Cohesive treats that gap as a language-design problem: define reusable system constructs, give them semantics, and realize them through compiler-driven projection.

The Gap

Teams can talk about system design in natural language. They can implement the design in programming languages. What is missing is the language layer between them: a reusable semantic representation for entities, transitions, invariants, relations, projections, policies, workflows, effects, boundaries, infrastructure requirements, and agent-facing context.

Today those constructs are usually implicit in local implementation. Because there is no portable system-level IR, every layer has to rediscover and reconnect the same meaning through boilerplate, adapters, duplicated contracts, generated glue, and convention.

Without that layer, design patterns remain informal. They are useful as names, but the reusable idea usually dissolves into classes, handlers, schemas, queues, controllers, jobs, configuration, dashboards, and team convention. The pattern is implemented, but it is no longer visible as a modular system construct.

The Semantic System Graph

Cohesive's answer is the semantic system graph: an authored source artifact that names the system's meaningful structure before it is lowered into a stack.

The graph is where implicit structure becomes explicit system semantics. It declares what exists, what can happen, what must remain true, which views are derived, which effects cross boundaries, which processes continue over time, and which realizations preserve the intended meaning.

A Family Of Languages

Cohesive is organized as a family of block-specific DSLs over one semantic graph. Each block gets the primitives it needs, and each definition lowers into the host language and runtime artifacts that realize it.

Core defines shared shapes, values, observations, expressions, and annotations. Entities define identity, state, invariants, transitions, effects, and lifecycle semantics. Relations define mappings, queries, projections, joins, and derived views. Processes define workflows, waits, decisions, child processes, retries, signals, and outputs. API, Presentation, Identity, Storage, Configuration, Infra, Machines, and AI contribute their own graph constructs without becoming separate sources of truth.

Realization Through Compilers

The technique is programming-language design applied to system construction. First define the right primitives. Give them domain semantics. Then give them operational semantics by compiling them into concrete artifacts: code, schemas, queries, generated clients, workflow definitions, state machines, policies, runtime bindings, infrastructure requirements, tests, diagnostics, and agent context.

This is why Cohesive is not primarily a methodology. A methodology can teach a team how to talk. A language and compiler can preserve the construct after the conversation ends.

The practical path is bottom-up as well as top-down. Existing code constructs, framework patterns, type systems, analyzers, source generators, and runtime libraries are not discarded. They are the material from which higher-level system primitives can be distilled, tested, hosted, and compiled back into the technologies teams already use.

Reading Path

Start with the broad lenses, then move into the article and knowledge-graph material that develops the details.