You use Notion for notes. Google Calendar for events. A CRM for contacts. ChatGPT for thinking. Maybe Obsidian for personal knowledge. Telegram for quick captures. A dozen browser tabs for things you'll "read later."

Each tool owns a fragment of your context. None of them can see the full picture. And your AI — the tool that's supposed to help you think — starts every conversation from zero, because it can't access anything beyond its own chat history.

The problem isn't that you have too many tools. It's that your data is scattered across systems that don't talk to each other, owned by vendors who have no incentive to let it leave.

Here's what most people get backwards about AI: they think the model is the valuable part. It's not.

GPT-4 was state of the art for eleven months. Claude replaced it. Gemini caught up. Open-source models are closing the gap every quarter. The model layer is commoditizing faster than any technology in history.

What doesn't commoditize is your data. Your context. The relationships between your notes, tasks, contacts, projects, and ideas — the accumulated structure of how you think and work.

When you switch from ChatGPT to Claude, you start over. All the context you built — the conversations, the patterns, the things the AI learned about how you think — gone. Not because the new model is worse, but because the old model owned your context and the new one can't access it.

A Synap pod is a dedicated private server provisioned for one user. Not a shared database. Not a row in someone else's table. A real PostgreSQL database, on a real VPS, that belongs to you.

Everything you capture — notes, tasks, contacts, files, bookmarks, conversations — lives in your pod as structured entities. Standard PostgreSQL. Notes stored as Markdown. Full-text search via Typesense. Semantic search via pgvector. Files in S3-compatible storage.

This isn't a technical choice for technical people. It's a philosophical one: your data should be stored in formats that work without Synap. If we disappear tomorrow, your pod keeps running. You can connect any SQL client to it. Export everything as JSON. Move it to your own server. The data is yours in every meaningful sense.

Sovereignty isn't a feature. It's an architectural guarantee.

Most software ships features. Synap ships primitives.

The core of Synap is three building blocks: entities (typed data objects), views (rendering configurations), and channels (communication flows). These are the Lego bricks. Individually, they're simple. Combined, they produce behaviors that no one — including us — designed explicitly.

This is emergent complexity: the idea that sophisticated behavior should arise from simple parts combining, rather than from complex features being coded one at a time.

The test we apply to every product decision: if a new capability requires special-casing in the code rather than composing from existing primitives, it's the wrong approach. Complexity should emerge from combination, not from addition.

This is why Synap can be a CRM, a project manager, a research tool, a personal wiki, and a knowledge graph — without being any of those things explicitly. They all emerge from the same three building blocks.

In most tools, AI is a feature — a chatbot sidebar, a summarization button, an autocomplete suggestion. The AI is bolted onto the product after the fact. It can see what the product lets it see.

In Synap, AI is infrastructure. It connects to your pod through the Hub Protocol — a standardized API contract that gives it structured access to your entire knowledge base. Not a chat history. Not a document dump. Your actual entities, their relationships, their properties, their history.

Any AI model that implements the Hub Protocol can connect to any pod. Claude today. GPT-5 tomorrow. A local model you run on your own hardware next year. The protocol is the constant. The model is the variable.

This means your AI gets smarter not by upgrading the model, but by having better data. The model improves the reasoning. Your pod provides the context. Separate concerns. Both can evolve independently.

There's a real tension in AI-powered tools: you want AI to be autonomous enough to be useful, but controlled enough to be trustworthy. Most tools resolve this by limiting what AI can do. We resolve it by making everything AI does visible and reversible.

Every AI write operation in Synap goes through the proposal system. The AI doesn't modify your data directly — it proposes a change, shows exactly what it wants to do and why, and waits for your approval. You can accept, reject, or edit before anything touches your data.

On top of that, every change — whether made by you, by AI, or by a connector — is recorded in an immutable event chain. Not a "last modified" timestamp. A full history: what changed, when, by whom, and why.

This isn't a safety setting you enable. It's how every write works, for every user, always. AI can be genuinely autonomous because the architecture makes it impossible to act without a trace.

Here's what excites us most about the emergent complexity model: we don't know what people will build with it.

The cell system in Synap is a universal rendering unit. Everything you see — an entity card, a kanban board, a chart, a map, a custom widget — is a cell. Cells render anywhere: full screen, in a sidebar, embedded in a document, or as a tile on a dashboard.

AI agents can compose existing cells into new arrangements. But they can also create entirely new cell types — sandboxed, reviewed through the proposal system, and deployable instantly. An agent that understands your data structure can generate a visualization you never asked for, because it saw a pattern you didn't.

The package system extends this further. Packages are composable blueprints — entity profiles, views, automations, and dashboard configurations bundled together. A CRM package and a project management package install on the same pod, sharing the same data and AI layer. Third-party developers can publish packages to the marketplace. AI can generate them on the fly.

We're not building a product with a fixed set of features. We're building a substrate — a system of simple parts that can be composed into things we haven't thought of yet. The most interesting use cases for Synap are the ones we can't predict.

Three shifts are converging that make this the right moment: