Cohesive Systems

Software systems need a language of their own.

Cohesive is a language family for system intent. People and agents use it to turn product decisions and technical constraints into durable system knowledge that compilers carry into software that runs.

See how it works Explore the vision

Scroll to explore

The new bottleneck

Systems outlive the context that created them.

As agents make implementation faster, product and technical intent still fragments across the tools used to decide, build, and run the system. Every change begins by reconstructing what must remain true, giving meaning room to drift.

ContinueLet system knowledge accumulate.

Explore freely. Commit precisely.

Let system knowledge accumulate.

People and agents can explore possibilities in natural language. Cohesive gives accepted decisions a precise, reviewable form. Governance belongs at that commitment boundary, where durable system knowledge begins to accumulate.

ContinueA language family for the whole system.

From meaning to runtime

A language family for the whole system.

From domain rules to runtime bindings, Cohesive lets you start with one concern and expand as needed. The languages connect at defined boundaries, so system knowledge compounds.

Model

Define shared structure, relationships, state, and legal change.

Coordinate

Connect work across time to identity and authority.

Project

Carry meaning into interfaces, tools, and intelligent systems.

Realize

Bind the graph to data, environments, and deployment targets.

01 / Relations

Define how entities relate to one another.

Product commitmentA shipment's customer relationship is defined once and can be reused wherever it is needed.

Relations make the connections between entities explicit and reusable wherever the system needs to query or enforce them.

Graph resultThe graph now has a reusable, traversable relation with explicit provenance.

ShipmentRelations.cs

var author = RelationQuery.Expression();
var shipments = author.Source<Shipment>();
 
var customers = author.Traverse<Shipment, Customer>(
    shipments,
    shipment => shipment.CustomerId);
 
var summaries = author.Project(
    customers,
    (Shipment shipment, Customer customer) =>
        new ShipmentSummary
        {
            Id = shipment.Id,
            CustomerName = customer.Name
        });
 
var relation = summaries.BuildRelation(summary => summary.Id);

02 / Entities

Define what can change.

Product commitmentOnly a draft shipment can be tendered.

Entities make identity, state, invariants, and legal transitions explicit wherever the system depends on them.

Graph resultThe graph now contains an explicit precondition, state change, and resulting event.

Shipment.cs

public sealed class Shipment : Entity<Shipment>
{
    public Shipment()
    {
        Status = Field(nameof(Status), ShipmentStatus.Draft);
 
        Tender = Transition<TenderInput, TenderOutcome>(
            ShipmentSemantics.Tender,
            transition => transition
                .Requires(
                    (shipment, _) =>
                        shipment.Status == ShipmentStatus.Draft,
                    (_, _) => TenderOutcome.NotDraft)
                .Set(
                    shipment => shipment.Status,
                    ShipmentStatus.Tendered)
                .Emit(
                    ShipmentInteractions.Tendered,
                    (_, input) =>
                        new ShipmentTendered(input.CarrierId))
                .Return(
                    TransitionOutcomeDisposition.Applied,
                    TenderOutcome.Tendered));
    }
 
    public Field<ShipmentStatus> Status { get; }
 
    public Transition<Shipment, TenderInput, TenderOutcome> Tender { get; }
}

03 / Processes

Define what unfolds over time.

Product commitmentA tender request reaches an explicit accepted or declined outcome, and preserves what happened.

Processes connect relations, transitions, effects and time into durable, inspectable workflows.

Graph resultThe graph now contains a linked query, typed request, and entity transition as one durable process.

TenderShipment.cs

[GenerateProcessDefinition(nameof(Run))]
public static partial class TenderShipmentProcess
{
    static async ProcessTask<TenderShipmentResult> Run(
        ProcessContext process,
        TenderShipmentInput input)
    {
        var carrier = await process.Query<Carrier>(
            relation: ShipmentRelations.EligibleCarrier,
            input: input.ShipmentId);
 
        var response = await process.Effect<TenderResponse>(
            contract: ShipmentInteractions.RequestTender,
            outcome: ShipmentInteractions.TenderResponded,
            input: new TenderRequest(
                input.ShipmentId,
                carrier.Id));
 
        if (!response.Accepted)
            return new(input.ShipmentId, TenderStatus.Declined);
 
        await process.Transition(
            transition: ShipmentTransitions.Tender,
            subject: input.ShipmentId,
            input: new TenderInput(carrier.Id));
 
        return new(input.ShipmentId, TenderStatus.Tendered);
    }
}

ContinueBind the graph to what already runs.

Binding and realization

Bind the graph to what already runs.

Bindings connect the graph to existing databases, services, workflow engines, and environments. The graph becomes a semantic control plane for understanding and evolving what runs; existing infrastructure still performs the work.

For agentic interaction, it is designed to provide focused context, explicit capabilities, durable workflows, authority, and runtime evidence.

Understand and change the system

Product views
Builders
Agents
Compilers

Focused contextCapabilitiesWorkflowsAuthority

Semantic control planeSemantic System GraphShared identities · invariants · operational obligations

Example realization targets

PostgreSQL
Cosmos DB
Kafka
Redis
Elasticsearch
Temporal
Azure
AWS
Kubernetes
Docker
Pulumi
Terraform
Aspire
PostgreSQL
Cosmos DB
Kafka
Redis
Elasticsearch
Temporal
Azure
AWS
Kubernetes
Docker
Pulumi
Terraform
Aspire

ContinueThe value compounds with the system.

Durable systems

The value compounds with the system.

Start with one entity, relation, or process. Each accepted definition gives the next change more context, so adoption can remain incremental. The value grows when a system carries meaning that must stay true through repeated change, even when the codebase itself is modest.

ContinueThe language has to earn its place.

An empirical thesis

The language has to earn its place.

Research and industry experiments point to a need for precise specifications, durable context, and realistic verification. We test Cohesive across successive changes to working systems to see when a language for system intent improves development enough to justify its cost.

What the experiments measureSame system. Same changes. Same checkpoints.

IntegrityCorrectness + safety

Semantic correctness · capability safety

ChangeChange + understanding

Change efficacy · comprehension · agentic leverage

FitFit + adoption

Portability · incremental adoption

ContinueStart with one meaningful slice.

Realize system intent

Start with one meaningful slice.

Choose a product commitment, rule, or workflow people depend on. Express it in Cohesive, follow its meaning into software that runs, and extend the graph when the next concern matters.

Explore the building blocks Read the vision Talk with us