Your questions. Direct answers.

Unifyhub is a community experiment in a new way of organizing collaboration: a shared coordination layer for identity, policy, audit, events, and migration, built in the open by the people who use it and designed to pass into their ownership. Ten shared capability planes sit on the layer, and the experiments built on it are proof it holds. The vision carries the long answer.

The entire design argues the opposite, and you should judge the design rather than the promise: public contracts, community-owned records, portable identity, and a tested right of exit. The boundaries page lists the lines that, if crossed, would make us exactly that.

The contracts, the governance rules, and this entire site are public and versioned in the open. Reference implementations are planned where they make exit credible. Some implementation detail may stay private; the agreement never does. The compatibility principle states the standard we hold ourselves to.

Self-hosting is a design goal with teeth: the architecture treats operability (updates, observability, backups, migration) as part of self-hosting rather than an afterthought. The layer is cloud-native and hybrid by design, and the experiments on it are early, so check the roadmap for what is real today.

Export by default in documented formats, published migration guidance, and identity built to travel. Leaving with your operating record intact is a supported outcome, and the business is built to survive it.

An all-in-one workspace binds your coherence to one vendor's application. Unifyhub puts the coherence in a shared, public layer (identity, policy, audit, events, migration) and keeps everything on top of it replaceable.

As a trust issue first. Any agent acting for a community carries auditable identity, acts under explicit delegation, and can be reviewed and revoked. Capability that cannot meet that bar stays out of the community's record.

Federation is designed as a governed choice and arrives only with the policy, abuse, and audit work that makes it safe to govern. Reach without governance pushes risk onto communities, so we refuse that trade.

The economics are care rather than captivity: managed hosting, security, continuity, migration support, and operations, sold by Unifyhub's ventures and mission companies. Unifyhub itself earns from the licence fees and profit they return. Pricing follows the first experiments; the principle that pricing can never punish leaving is already fixed.

The substrate, the delivery path, and the foresight practice carry real work today, several experiments are in build and used to build the rest of the system, and the first narrow experience aimed at communities is the current focus. The roadmap separates what is running from what is written down.

Twelve use cases walk through ordinary situations: a purchase becoming a defensible ledger line, a tender caught before its deadline, a question answered from your own records with sources attached, a task delegated to software and reviewed before it lands, and a small organization taking back a service a vendor had quietly come to own. Each one names the parts of the system doing the work, so the abstract layers can be checked against something concrete.

Because the promise is coherence, and coherence cannot be delivered by one application without capturing everything it touches. The breadth is deliberate: shared foundations built once, capability planes every experiment draws on, and domains that keep their own integrity. What keeps breadth from becoming sprawl is that each part has one job, a stated boundary, and a public contract, checked by tooling rather than by memory.

No, and a design that required it would contradict the entire thesis. Domains are separable, a node runs only the services it needs, and the shared layer is what makes partial adoption coherent instead of fragmentary. The honest caveat is that the guarantees come from the shared layer, so a community adopting one domain without identity, policy, and audit gets a useful tool rather than the promise this site makes.

Every part publishes a machine-readable account of itself, and those accounts join into one map with provenance. Documentation is treated as the source of truth for behavior rather than a description of it, and where the map and the system disagree that is a defect with an owner. A system that cannot explain itself cannot be governed, which makes legibility a requirement rather than a nicety.

Delegated software does a large share of the work, under the same identity, policy, and audit rules people work under, with scoped authority and real revocation. The reason to say so plainly is that this is the part most platforms leave vague. An action taken on a community's behalf carries who acted, on whose authority, what was checked, and what a reviewer accepted, or it does not happen.

In two layers: the community governs and shares the benefits, and the companies are its legal tools. Today the founder owns and runs the company under published guardrails; at a measurable handover point the owner rights pass to a representative the community elects and can recall. Commercial ventures license Unifyhub's shared technology and return their profit; private investors are kept out. Trust is the unit of measure of a contributor's standing.

Read who we are looking for, pick a way to shape this, or answer an open question. The invitation asks for direction rather than agreement.