Most software is built by accretion. Year one: notes. Year two: tasks. Year three: a CRM module. Year four: a project management view. Each feature is a separate piece of code, designed once, maintained forever.

This is how you end up with products that do twenty things and none of them well.

Synap takes a different approach. Instead of building features, we build primitives.

There are three: entities (typed data objects), views (rendering configurations), and channels (communication flows). That's it. Everything in Synap is built from these three building blocks.

A "task" is an entity with a status property and a due date. A "kanban board" is a view that groups entities by a property value. A "project" is an entity that links to other entities. A "CRM" is a set of entity profiles (contact, company, deal) and a set of views (pipeline kanban, contact table, deal timeline).

None of these required special code. They emerged from combining the same three primitives in different ways.

When you add a feature to traditional software, you add complexity. More code, more edge cases, more maintenance. The cost of the next feature goes up because it has to work with everything that came before.

When you add a new entity profile or view type in Synap, the cost is roughly constant. A "deal pipeline" is no more complex than a "task board" — both are just a view configuration applied to a set of entities. The system doesn't get heavier as it gets more capable.

This is where it gets interesting. AI agents in Synap don't just query data — they can compose primitives.

An agent that understands your entity profiles and view types can generate a new dashboard layout, create a new entity type for a workflow you didn't plan for, or restructure your data into a shape that reveals a pattern you didn't see.

The cell system takes this further. Everything visible in Synap — every card, chart, widget, and view — is a "cell" that renders anywhere. AI can compose existing cells into new arrangements, or create entirely new cell types in a sandbox environment.

We've seen this produce results we didn't design: an agent that noticed a user's reading notes clustered around three themes and generated a visual comparison dashboard. A workspace that restructured itself when a project's scope changed. Connections between entities that the user had never explicitly linked.

We apply one test to every product decision: if it requires special-casing in the codebase rather than composing from existing primitives, it's the wrong approach.

This discipline is what allows Synap to be a note-taking app, a task manager, a CRM, a research tool, and a knowledge graph — without being any of those things explicitly. They emerge from the same three building blocks.

Complexity should emerge from combination, not from addition.