Toward organizational intelligence

The problem

When you decide to launch a product, you're running a simulation. When you choose a strategy, you're predicting futures. When you plan a project, you're modeling a system of people, resources, and constraints. You do this constantly, automatically, in your head.

The trouble is that mental simulations are invisible. They can't be shared, versioned, or improved. When they're wrong — and they often are — there's no record of why. The organization learns nothing from its own reasoning. The next decision starts from scratch.

This is why most organizations are less intelligent than the people in them. Individual expertise exists, but it doesn't compose. Knowledge lives in heads, in documents, in spreadsheets that model fragments of reality without connecting to each other. The organization can't reason about itself.

The infrastructure

Software engineering solved a version of this problem decades ago with git. Code is versioned. Every state is recoverable. Branches let you explore without risk. Merging integrates parallel work. The entire history of decisions is preserved and inspectable.

But git only works for code. The rest of organizational knowledge — processes, decisions, predictions, outcomes — has no equivalent infrastructure. We write documents that go stale, build spreadsheets that can't branch, make decisions that leave no trace of the reasoning that produced them.

The deeper insight is that organization is itself a form of simulation. An organization that manages knowledge well is implicitly modeling its world — tracking what's true, predicting what's next, deciding what to do. We make this implicit model explicit, forkable, and learnable.

How it works

You start with a conversation. You structure what you know. The system builds a queryable model from your knowledge. When you want to test a decision, you branch the model, apply the change, and compare outcomes. The system observes what actually happens and refines its predictions. Knowledge compounds.

AI agents participate as collaborators, not oracles. They operate in sandboxed, versioned environments — writing code, running analyses, building sub-models. Each agent maintains persistent memory and grows expertise over time. They're members of the team, not services you call.

This isn't a tool that prescribes how you should work. It's a medium that adapts to how you think — a collaborative, growing experience that gets better the more you use it. Complexity emerges from use. It's not imposed upfront.

Open by design

Underneath, every component shares one primitive: copy-on-write branching. The database, the analytical engine, the search index, the agent runtime, the reactive computation system — all of them fork at zero cost, all of them compose through a shared versioning protocol. This is what makes simulation cheap enough to be part of everyday work rather than a special event.

We believe the infrastructure should be open. The database stack — Datahike, Stratum, Yggdrasil, Konserve — is open source and independently useful. The computational layers — Raster, Ansatz, Spindel — are open. The value we capture is in the integration, the managed platform, and the trained models that make the system intelligent for specific domains.

The goal is a platform where organizations can model their world, simulate their decisions, and learn from the outcomes. Not by replacing human judgment, but by making the consequences of choices visible before you commit to them. Think it through — then act.