Open infrastructure, built in public

Your cooperative owns its work.
It should own its institutional memory too.

The InterCooperative Network is shared digital infrastructure for cooperatives, communities, and federations. It connects the rules an institution sets, the decisions it makes under them, the actions that follow, and the durable proof of why — instead of scattering those across six products owned by somebody else.

See ICN work Start reading

Under active construction, and honest about it — what's real now states what each part of the system can and cannot do today.

The problem

An institution's memory is scattered across tools that don't know about each other.

Every cooperative already has governance, rules, membership, money, and work. What it usually doesn't have is any system that holds those together — so the connections live in people's heads, and leave when they do.

A comparison of where an institution's authority and memory live today versus how ICN connects them. Today's column lists seven separate systems, each holding one fragment. The ICN column lists six connected stages that form a single loop.

Today Seven systems, none of which know about each other

  • Chat The discussion that led to the decision
  • Documents The rule everyone is meant to follow
  • Voting tool The decision itself
  • Spreadsheets Who is a member, and since when
  • Accounting What the decision cost
  • Task tracker Whether anyone did it
  • Cloud vendor All of the above, on their terms

Every link between these is a person remembering. When that person leaves, the link goes with them.

With ICN One sequence, and it closes

  1. Members Who is recognized here, and provably so
  2. Rules What the institution has agreed to
  3. Decisions What it decided, under those rules
  4. Action What was actually done about it
  5. Proof A record of why that was allowed
  6. Memory All of it, still connected, years later

Each stage carries a reference to the one before it, so the last one can still explain the first.

The deeper version of the problem

Underneath the operational friction is a dependency problem. Democratic institutions are expected to run their internal life on systems controlled by outside owners, with outside incentives and outside priorities. A cooperative can own its workplace outright and still rent its nervous system.

Why this is structural, not just inconvenient

What this looks like in practice

A forty-person cooperative needs to replace a fan.

How it usually goes

  1. Someone raises it in the shop channel. It scrolls away.
  2. It comes back at a meeting. The minutes land in a shared drive.
  3. A vote happens in a separate tool. The result is pasted back into chat.
  4. Someone orders the fan. The invoice goes to the bookkeeper.
  5. Eighteen months later, an auditor asks who authorized it.
  6. Three people spend an afternoon reconstructing the answer.

With ICN

  1. The cooperative already has a rule about who decides safety spending.
  2. The item appears as work needing a decision, with a deadline.
  3. The person acting can see exactly what authorizes them to act.
  4. Before confirming, they see what record it will create, and whether it can be undone.
  5. Completing it produces a receipt that points back at the decision.
  6. Eighteen months later, the answer is one link, not an afternoon.

Nothing above removes the meeting, the argument, or the judgement. The people still decide. What changes is that the decision stops evaporating the moment it's made.

What changes

Rules stop being documents people are expected to remember, and start being the thing that determines what can happen next.

That is the whole shift, and it is narrower than "ICN fixes democratic institutions." Deliberation, politics, judgement, and responsibility stay with people. What the infrastructure contributes is memory, continuity, and the ability for an institution to be legible to itself — so that running a cooperative rests on something more durable than whoever is currently holding the pieces together.

It also means an institution can answer questions about its own past without depending on a vendor to still exist, still export, and still be telling the truth.

The model

Six stages, and the last one feeds the first.

This is the introductory view. Underneath it, ICN models nine stations with more precision — the mapping is shown on each stage so the simple version is a view of the real thing, not a separate story told to newcomers.

The simplified ICN loop in six stages: people, rules, decisions, action, proof, and memory. The sixth stage returns to the first — the record of what happened becomes context for the next decision.

  1. People

    Who is recognized here, and what they are recognized for.

    In ICN: identity standing

  2. Rules

    What the institution has agreed to, and who may act under it.

    In ICN: authority policy

  3. Decisions

    What it decided, using the rules it set for itself.

    In ICN: governance

  4. Action

    What actually happened as a result — including what it cost.

    In ICN: execution accounting

  5. Proof

    A durable record of what happened and why it was allowed.

    In ICN: provenance

  6. Memory

    All of it still connected, so the next decision starts informed.

    In ICN: member experience

Memory feeds back into people and rules. That return is the whole point — an institution that cannot remember why it decided something has to decide it again from scratch.

See the full nine-station architecture

The worked example

Watch one decision travel the whole loop.

A short guided walkthrough of a fictional cooperative: who counts as a member, what needed deciding, which rule permitted it, what would happen before anything happened, and the record that can still explain it a year later.

No account, no download, no command line. Around four minutes. Every value in it is invented, and the page says so at every step.

Open the walkthrough
  1. 01 Someone is recognized by their cooperative
  2. 02 Something comes up that needs a decision
  3. 03 The rules say who may decide it, and why
  4. 04 Before anything happens, you can see what would happen
  5. 05 What happened leaves a record that can be checked
  6. 06 The record joins the institution's memory
Current state

What is actually built, and how we know.

ICN's subsystems are at very different stages, and the project publishes that unevenness rather than averaging it into a reassuring summary. Two labels travel with every claim: how far along it is, and what kind of evidence sits behind it.

6 of 10 subsystems in the strong today band

Economics (Mutual Credit Ledger), Entity Model, Governance, Identity & Cryptography, Network & Transport, Security & Privacy.

1 still not yet

Distributed Compute — scaffolding exists, the capability does not.

2026-08-14 last verified against source

Generated from the repository's own state file on every build, so this page cannot quietly fall behind the code.

What none of this means

ICN has no production deployment claim and no live federation. A subsystem can be well-built and still only ever have been exercised against prepared data — several are. Evidence labels like Fixture-backed exist precisely so that distinction survives contact with a homepage.

The full per-subsystem account, with recorded gaps

Going deeper

If you want the actual system.

How it works

The nine stations in full, each with its own maturity band — identity through to the member-facing surface.

Architecture

The constraint engine, the kernel/app boundary, and why the kernel is deliberately kept ignorant of institutional meaning.

The cooperative economy

Why credit unions and CDFIs are bridges to the existing economy, and what machinery the other side of that bridge still lacks.

Documentation

Current reference, the decision record, and a clearly-marked archive of everything that used to be true.
Taking part

Now that you know what this is.

Four routes, each leading somewhere that is actually maintained. If a path below turns out to be a dead end, that is a bug and we would like to hear about it.

You write software

Build the workspace, read the architectural guardrails, and pick a scoped first issue. The repository is large and the contribution surface is real.

For developers

You organize, write, research, or design

Documentation, plain-language review, governance thinking, accessibility testing, translation. None of this requires writing Rust, and the project is short on all of it.

Non-technical contribution

You are part of a cooperative or institution

Understand what would actually be involved in evaluating ICN, what it can carry today, and what it plainly cannot. Honest answers before any commitment.

For cooperatives and institutions

You want to follow or support the work

Watch the repository for project updates, or sustain the engineering directly. No mailing list you would have to trust us to actually send.

Follow or support