the manifesto

Philosophy

An independent engineering collective making open-source software you can read, run and change.

The premise: digital tools should be transparent, run on hardware people own wherever privacy is the point, and give something back to the people who use them.

01

Independent logic, shared origin

Independent Logic: every tool is engineered to run autonomously. No dependency on proprietary auth or a platform hook that only one vendor controls, just to perform its core function. Local data stays local. Where privacy is the point, compute stays local too. A component stays fully operational even without the rest of the ecosystem.

Shared Origin: while each node runs independently, all uncoalesced software shares one engineering standard: strict memory management, lean interfaces, self-contained modules that talk over open protocols, and fully open data pipelines. That lets the tools work together without merging into one fragile whole.

Matte green, orange and red discs and cubes floating apart in mid-air against a dark background

02

Bringing the frontier local, whatever it takes.

Our goal, now and for the long term, is to bring the frontier local. The frontier is the most capable AI there is at any given moment. Today, using it means paying for access to someone else's servers and living by someone else's terms. We want that capability to run on hardware a person can reasonably own.

Whatever it takes means we keep at it for as long as it takes. Not every project we build has to run locally, and we aren't against the cloud. Training a frontier system today takes data centers, and running one takes far more hardware than most people have. The cloud is how that gets done for now, and we use it where it's the practical choice. What matters to us is who runs it and on what terms.

So the work is narrowing that gap: making capable models smaller and cheaper to run until they fit on hardware people already own. A self-driving car can't carry a data center, and neither can a robot. What they can carry is a small board and a small chip, so that is what the intelligence has to fit on. Small and practical is the goal.

Whether a project runs locally depends on what it's for. When privacy is the point, it runs on your own device and nowhere else. When running locally would put a tool out of reach for most of the people it's meant to help, because they don't have the hardware, we may host it instead. We make that call one project at a time.

03

Open Source First

Open source comes first. When we start a project, the aim is that anyone can use it, read it and change it, free of charge, and that aim outranks everything else.

We're making that a promise. When openness conflicts with another goal, openness wins, and what we have released openly stays open.

Work we build for other people follows their decision about how it's licensed. Some of it will be closed, and that's their call.

Models get the same treatment. We release everything: the weights, the training data and the pipelines, so anyone can reproduce the work and check it.

04

The reciprocal community loop

ships raw infrastructure& clean codestress-tests · audits · contributesuncoalesced collectiveglobal digital communityhardened ecosystemstandard

A lot of open source moves one way: one group ships, everyone else downloads. We run it as a loop that goes both ways.

  • We ship production-grade code under open licences, and every line of source, build config and deploy script for each project is published openly.
  • The community stress-tests it under heavy load, audits it for security and privacy leaks, and sends fixes and hardware ports back upstream.

We supply the blueprint. The community puts it through real-world friction. What comes out the other side is more resilient, more secure and faster than either side could make alone.

05

Five engineering directives

  1. Absolute Transparency

    No black-box modules, no obfuscated binaries, no undocumented network calls.

  2. Hardware Efficiency & Zero Waste

    Idle CPU cycles, unallocated threads, and idle GPU memory are treated as design defects.

  3. Modular Decoupling

    Backend, networking, database, and UI layers are strictly separable. Any layer can be swapped without breaking the rest.

  4. Protocol-First Interoperability

    Open, documented protocols (WebSockets, clean IPC, predictable filesystem layouts) instead of proprietary internal APIs.

  5. User Sovereignty

    No forced remote updates, no phone-home telemetry, no artificial feature gating. The user or admin keeps total control.

06

Ecosystem node topology

uncoalesced architecturestorage & datanodescommunicationprotocol nodescompute routing& resource nodes

Storage & Data Nodes

Local data handling, high-throughput file ops, no cloud required.

Communication Protocol Nodes

Lightweight point-to-point exchange and emergency paging, built for reliability under degraded network conditions.

Compute Routing & Resource Nodes

Monitor hardware utilization, harvest idle GPU/CPU for background compute, hand back to the user instantly on active input.

07

Contribution standards

  • We reach for core language primitives before third-party packages wherever that's practical.
  • Threads are isolated explicitly, so behaviour stays predictable under load.
  • Documentation covers the architecture, including performance trade-offs and memory layouts, as well as the API.

Security work happens in the open. Vulnerabilities, memory leaks and concurrency bugs are reported on public issue trackers, and the patches are merged in the open and versioned clearly.

08

Licensing & IP

Code is published under permissive licenses (MIT, Apache 2.0), so you're free to inspect, run, modify and redistribute it.

The uncoalesced name, project names, logos, and architectural documentation are protected under common-law trademark and copyright, so the name stays a reliable sign of code that is clean, lean and free of surveillance.

As commercial software closes into fewer, more restrictive platforms, we build the alternative: open-source tools that respect the hardware they run on and do their job well.

Engineered by uncoalesced.