A fresh look at the mess we need to compost

Our example of: Tactical Tech is a Berlin-based nonprofit that’s been around since the early 2000s, working on tech, activism, media, and education. Their core thing is:

  • building digital literacy + critical thinking tools
  • producing toolkits, exhibitions, and guides (like The Glass Room, Data Detox Kit)
  • working with civil society orgs, journalists, activists, educators
  • focusing on how tech shapes power, politics, and society

They’re not grassroots infrastructure builders, they’re capacity builders and narrative shapers, working through partnership networks, funding, and “field building” – classic NGO patterns.

In #OMN view they sit squarely in what we call the #NGO / #mainstreaming layer of the #openweb story. In that they don’t build the soil (infrastructure, protocols, messy grassroots tools). They build the interpretation layer (how people think about tech). They push this into narratives + toolkits that travel across institutions. That’s why they’ve lasted 20+ years – they’re adaptable mediators, not in anyway rooted projects.

So why dose it feels like “they create mess”? The friction comes from this pattern the balance of abstraction over grounding in that they translate messy realities into frameworks, exhibitions and “kits”. This flatten lived complexity into safer portable concepts, in to language production. They are part of the ecosystem that generates terms like digital literacy, resilience and sovereignty (adjacent space). These become floating signifiers – useful for funding and policy, messy in practice.

They collaborate with foundations, governments and large NGOs. So their outputs are shaped to be fundable, presentable and non-threatening enough to circulate. That’s where the “compost” instinct kicks in – because this layer detaches language from practice.

But it’s not just negative, if were honest (and it’s worth being), groups like this do some real things. They’ve help millions engage “critically” with tech issues to make complex problems accessible (privacy, AI, influence systems). They might create bridges between activists, educators, and institutions. So they’re not empty, they’re just not where the roots are.

The real tension, the problem isn’t that they exist, it’s where they sit in the ecology. They are compost producers, but they mistake themselves for gardeners. Or more sharply

  • They circulate meaning rather than anchor it
  • They mediate change rather than enact it
  • They stabilize narratives that should sometimes stay unstable

So yes – they create “mess” …but it’s a different kind of mess than grassroots paths. Grassroots mess = fertile, emergent – #NGO mess = abstracted, packaged, drifting.

Projects like Tactical Tech can be a part of the same ecosystem we need – but they sit one layer up from where change actually happens. Their outputs duse need composting because they generalize lived practice into frameworks, turn struggle into language and then feed that language back into systems which tends to blunt its edges.

The task isn’t only to reject them, it’s to ground what they produce back into lived, messy, trust-based practice – the bit they can’t really do. Once you see this pattern, a lot of the confusion in the #openweb space makes sense.

• Soil layer → messy, native, trust-based (#indymediaback, grassroots, actual users)
• Infrastructure layer → protocols, servers, code (#ActivityPub, Fediverse devs)
• Mediation layer → governance, coordination (#OGB-type thinking)
• Narrative/NGO layer → language, framing, funding-facing outputs
• Power layer → states, corporations, capital (#dotcons)

Most confusion comes from people mixing these layers up, Here are a few examples of these groups and organisation.

Tactical Tech – Layer: Narrative / NGO
Role: Translator of tech → society
What they do (in practice)
• Turn complex tech issues into stories, exhibitions, toolkits
• Shape how civil society talks about tech
• Build “awareness” rather than infrastructure

In #OMN terms they produce processable compost input, but often pre-packaged into neat bags. This problem pattern flattens messy reality into clean narratives to encourages passive understanding over active building. So what is there value? Good at onboarding people, opens doors into the conversation. But risk is people stop at understanding instead of doing.

Mozilla Foundation – Layer: Narrative + Funding + Soft Infrastructure
Role: Bridge between grassroots + institutions
What they do is fund projects to run advocacy campaigns (AI, privacy, etc.) that maintains a symbolic connection to the #openweb. In #OMN terms they gate keep legitimacy to define what is “acceptable open”. This is a problem pattern because of NGO gravity → safe, fundable ideas win, radical edges softened into “trustworthy AI” and “ethical tech”. So what is the value? Real money → keeps projects alive and visibility → amplifies issues. The risk is common sense #mainstreaming capture that shapes agenda toward what institutions tolerate. Makeing only more mess to compost.

Open Society Foundation – Layer: Power / Funding
Role: Macro-level agenda shaping
What they do is fund civil society globally to influence policy, rights frameworks, governance. In #OMN terms its a part of the liberal wing of the #deathcult. Problem being funding creates dependency, agenda alignment when movements adapt to grant logic. Value is it enables work that wouldn’t exist otherwise to support rights-based infrastructure. The risk is it turns movements into professionalised NGOs and risk-averse actors.

Sovereign Tech Agency – Layer: State / Infrastructure funding
Role: Stabiliser of critical open tech
What they do is fund maintenance of open-source infrastructure with a focus on “digital sovereignty” In #OMN terms they are trying to support the infrastructure layer by using state-language framing. Its a problem pattern as language like “sovereignty” pulls toward state/control logic and away from commons/trust logic. What is the value? It pays for the essential work to keeps #FOSS tools alive. But it risks reframes the #openweb as national infrastructure instead of shared commons.

NLnet Foundation – Layer: Infrastructure funding (closer to soil)
Role: Rare “good compost feeder”
What they do is fund small, weird, early-stage open projects with minimal interference. In #OMN terms one of the few funding bodies that, could in theory not over-shape outputs to respect messy innovation. But the are problem pattern of limited scaling and still within funding constraints, Value is they enables actual building and possibly supports non-mainstream ideas. The risk is the normal that they still are pulled into NGO gravity over time.

Electronic Frontier Foundation – Layer: Advocacy / Legal
Role: Defensive shield
What they do – Legal battles, policy advocacy and civil liberties protection. In #OMN terms they protects space for the #openweb to exist. But the are problem patterns, the focus on defence, not creation that only works inside existing legal frameworks. Value they are absolutely necessary to stops things getting worse. The risk is they doesn’t build alternatives = slowing decline, not transformation.


The pattern, is all these orgs sit above the soil. They translate, fund, shape, defend. But they rarely grow rooted communities of sustaining messy trust networks or live with the consequences. So why dose this create “mess” it is because language drifts away from practice. Ideas come and go: “digital sovereignty”, “trustworthy AI” or “resilience”. These sound solid, but float free of lived reality, then incentives bend behaviour. Funding → reporting → metrics → simplification is when mess gets cleaned up too early or packaged instead of composted

The #geekproblem + NGO problem merge, you get geeks wanting to tidy systems and #NGOs wanting to tidy narratives. The result is over-simplified systems + over-simplified stories. The #OMN position is clear and grounded, we don’t reject these orgs, we place them correctly: Useful → yes, Central → no and ground truth → never.

The simple way to say this (#KISS) These organisations sometimes help explain, fund, and defend the world, but they do not remake it. If we mistake them for the source of change, we end up with only better words and worse reality. The next stage is a practical progression from “mapping the mess” → “building something that can survive it”.

To make anything work we need to stop confusing layers (cognitive clarity) – Before anything technical the path needs to never treat NGO / funding / advocacy layer as if it is THE system. This is the correction, in #OMN terms:

  • NGOs ≠ infrastructure
  • funding ≠ governance
  • narratives ≠ reality
  • protocols ≠ politics

The outcome is people stop trying to “fix the web” by only better policy decks, better ethical frameworks, better terminology (like “digital sovereignty”). And start asking “What is actually being built, and by whom?”

How to do this? we need to build the soil layer first (not apps, not orgs) as this is where most projects fail. The soil layer is trust groups, working collectives, repeated interaction spaces and small-scale publishing + coordination. In #OMN framing #indymediaback style groups, #OGB governance spaces and local + affinity networks. If it doesn’t survive social breakdown, it isn’t infrastructure.

Define “failure as feature” systems, is one of the strongest #OMN ideas. Instead of perfect systems that must not break – We grow systems that fail into human repair. What that means in practice is moderation doesn’t escalate → it returns to people, governance doesn’t lock → it re-opens, conflicts don’t freeze → they surface into trust spaces. The principle is breakage must increase human contact, not reduce it, this directly counters the platform logic (#dotcons), #NGO sanitisation logic and geek “perfect system” logic.

Build mediation layers (not control layers). This is where #OGB thinking fits. Mediation layer ≠ governance authority, is translation between groups, conflict visibility, trust routing and decision recording (not decision ownership). We don’t centralise power – we route attention. This is the difference between bureaucracy (control) and federation (flow).

Define “trust as infrastructure” this is the “missing” technical core. Most systems assume identity, verification and thus control. #OMN flips this to assume partial trust, local trust, evolving trust and broken trust. So native systems must record trust signals (lightweight) to allow contradiction, allow decay and allow repair. Trust is not a certificate, it is a living flow.

Explicitly resist “narrative capture”. This is where orgs like Tactical Tech / Mozilla / OSF become relevant. The patterns to avoid – messy reality emerges, #NGO translates it, funding aligns around translation and original practice disappears. #OMN counter-path is if it can be fully explained in a funding report, it is likely already dying. So we maintain ambiguity, partial documentation and lived process > polished narrative.

Build dual-stack reality (critical stage). This is essential, you always run:

Native stack (real community power)

  • trust networks
  • local groups
  • Fediverse-native tooling
  • #4opens processes

Interface stack ( individual survival layer)

  • NGO language when needed
  • funding language when needed
  • policy translation when needed

The path is never confuse the interface with the infrastructure.

So what are composting failures? Instead of discarding failed projects, rewriting history and blaming actors. We need to explicitly turn failure into reusable material. Compost includes:

  • broken governance attempts
  • failed funding models
  • collapsed communities
  • conflict histories

Output:

  • patterns
  • lessons
  • reused structures
  • new trust layers

This is where the “mess is valuable” idea becomes operational.

Anti-capture safeguards – Every healthy #OMN system needs resistance to #NGO capture, funding capture, geek capture and ideological capture. Mechanisms:

  • lose roles
  • refuse most permanent authority
  • keep systems reversible
  • enforce transparency (#4opens)
  • limit scale before complexity dominates

The long game is federated commons, at scale, the goal is not a platforms, it is many overlapping, messy, partially connected commons. Not one Fediverse or one governance model, not one truth layer. But overlapping trust regions, with shared protocols and local autonomy to weak global coupling.

The summary (#KISS version). If you compress all of this:

  1. Stop confusing explanation with infrastructure
  2. Build trust-first “soil systems”
  3. Design failure that returns to people
  4. Keep governance as mediation, not control
  5. Treat trust as a living system
  6. Resist narrative capture
  7. Run dual-stack (native + interface)
  8. Compost failure, don’t hide it
  9. Prevent capture structurally, not morally
  10. Scale as messy federated commons, not platforms

The shift is from “understanding the system” → to “acting in a small part of it without being captured” This means choosing a river, a locality, a topic, or a community and committing to working inside its mess without trying to abstract it into a universal model too early. #OMN path is if it doesn’t exist in a place, it doesn’t exist at all. This is where a lot of NGO / narrative layer work fails – it stays placeless.

Build “thin infrastructure”, the #OMN correction to both NGO thinking and geek thinking is that wrong instinct is to build full systems, design complete governance models, define everything upfront. #OMN instinct is to build the minimum structure that lets humans keep adjusting it together. Thin infrastructure = simple publishing tools, basic coordination spaces, visible decision trails and lightweight identity/trust signals. Nothing heavy, nothing “final”, because heavy systems attract control, thin systems attract use.

Make conflict visible, not resolved. This is where #NGO culture diverges hardest from native systems. NGO pattern is to resolve conflict, smooth disagreement and force consensus narrative. #OMN pattern is surface conflict so it can be worked with socially. Why, because in real networks conflict is information, disagreement is structure and tension is direction. The compost is if conflict disappears, it hasn’t been solved – it has been buried. Buried conflict always returns, festers, later as system failure.

Build “trust scaffolding”, not trust systems. This is subtle but crucial, you cannot design trust, you can only create conditions where trust can form and where it can fail safely. Trust scaffolding includes repeated interaction spaces, low-stakes collaboration, visible contribution histories and reversible decisions with clear exit paths. The path to trust is an emergent behaviour of stable mess, not a product of design. This directly opposes #mainstreaming ideas of identity systems, certification systems and techbro reputation scoring systems.

Explicitly reject “clean governance” as this is where most of well-meaning systems collapse. The trap is people try to build clean voting systems, formal representation and universal rule sets. But in messy reality governance is not clean – it is negotiated, situated, and constantly patched. #OMN path is instead of clean governance, we grow layered responsibility, overlapping legitimacy with temporary authority and visible disagreement. Think of governance as weather, not architecture.

Anti-scale principles (very important). Most systems fail because they assume more scale = more success The #OMN flips this with a path of scale should be resisted until coordination proves it is needed. Because scale introduces abstraction, funding dependency, narrative capture, bureaucratic drift. So instead we grow horizontally first, federate slowly and allow divergence to tolerate inconsistency.

Build “failure memory” as infrastructure, its one of the most underused ideas in the whole space. Most ecosystems forget failures, hide conflict history and rewrite past attempts. #OMN path is about failure is the most valuable dataset. So you build public failure logs, conflict histories and abandoned project archives with “why this didn’t work” notes. Not as shame, but as compost. Because systems that cannot remember failure are forced to repeat it.

Soil layer (real life)

trust groups
lived coordination
actual practice

Infrastructure layer

tools
protocols
servers

Mediation layer

conflict handling
coordination
routing

Narrative layer

NGOs
funding language
public explanation

Power layer

states
capital
platforms

On this working group path no layer is allowed to pretend it is another layer, the core anti-confusion mechanism.

So what is the actual #OMN outcomes, when this all works, you don’t get a platform, a movement or a unified system. You get a living field of partially connected commons that can adapt without central control, yes it looks messy from outside – and that’s correct. Because coherence is not the goal, survivability and humain flourishing is. lets reduce the whole thing to operational clarity: Build small, stay local. Keep systems thin, let conflict stay visible, treat trust as emergent. Avoid clean narratives, resist scale, remember failure. Separate layers to never centralise experimentation into control.

That’s where theory finally has to become dirt-under-the-fingernails practice, where the abstraction has to survive contact with reality. Lets look at some example work flows, different angles of the same living loop.

What a real example #OMN #oxfordboaters river project looks like day-to-day. The river communerty is not an organisation. It’s a persistent coordination affinity around a real place/problem/ecology (a river in this case). Daily reality looks like this:

Morning layer (signal gathering) when people notice things:

  • water quality change
  • planning notices
  • blocked access points
  • local council updates
  • photos from walks
  • stories from anglers / walkers / residents

This is not formal reporting, It’s messy input that lands in:

  • Fediverse posts
  • local group chats
  • simple shared logs

Mid layer (sensemaking) is when a few people (DIY, not fixed) do:

  • cluster reports (“this looks like sewage spike again”)
  • link patterns (“this happened upstream last month”)
  • tag relevance (#pollution #access #planning)

No authority – just attention shaping (or focalising).

Action layer (light coordination) is made up of small, reversible actions:

  • someone emails council
  • someone visits site
  • someone talks to landowner
  • someone checks data source
  • someone posts explainer thread

Crucially no one needs permission to act, only visibility into what others are doing

Weekly rhythm (social compression) is a loose gathering (online or physical):

  • “what changed?”
  • “what patterns are forming?”
  • “what are we missing?”
  • “what broke this week?”

No authority, rather shared memory and process. The river project is not a formal group. It is a shared affinity flow. That’s why it works (when it works) – it stays situated, porous, and continuously re-formed.

Lets look at a second example, how #OGB decision flows actually operate, it is not voting or governance in the institutional sense. It is a routing system for trust, conflict, and attention.

Step 1 – Issue appears, something surfaces

  • conflict
  • proposal
  • blockage
  • uncertainty

It is posted publicly (default open).

Step 2 – Context attaches, people attach:

  • experience (“this happened before”)
  • local knowledge
  • technical input
  • historical memory
  • disagreement

Important – contradiction is allowed and expected

Step 3 – Clustering happens (not authority). Instead of leaders deciding clusters of alignment form naturally, disagreement clusters remain visible and minority views persist. Think weather systems, not committees

Step 4 – Decision emerges as a path, not a vote – a “decision” is a visible “common” path of action with acknowledged alternatives still open. So nothing is deleted, nothing is finalised, nothing is owned

Step 5 – Follow-through is voluntary, but visible. People act based on trust in community, reasoning based on proximity and capacity. And they report back into the same system. The native path is the #OGB doesn’t only decide things – it makes decision pressure visible.

What a Fediverse-native governance loop feels like is where it becomes felt reality rather than structure. It feels like slow public thinking, less meetings, less agendas. More like threads that evolve over days, posts that accumulate context and replies that become infrastructure

Persistent memory in the stream, nothing disappears old decisions are still linkable, conflict history is visible and prior attempts remain accessible. So governance is navigation through lived memory. Weak coordination, strong transparency as no one is forced to agree. But disagreement is visible, reasoning is public and action is observable. This produces accountability without authority to grow temporary gravity centres.

Certain threads or instances become coordination hubs, discussion anchors and action nodes. But they fade naturally – nothing, but memmery is permanent. It feels like thinking in public with other people who sometimes act on what emerges. Not bureaucracy, not formal consensus culture. More like shared situational awareness that occasionally crystallises into action.

OMN / #OGB model is: surface → act → observe → remember → re-surface. It is governance more as continuous ecological process, less a fixed control structure.

Think that is anufe for today, please ask in comments to help finsh this.

The hashtag story is messy, that’s the Point

One of the constant pressures we face in #OMN and wider #openweb spaces is the urge to “tidy things up.” People arrive, see a messy landscape of hashtags – #geekproblem, #deathcult, #dotcons – and their first instinct is to fix it, define it, standardise it, make it neat and legible. That instinct feels sensible, but is also the #geekproblem.

The hashtag ecology we’ve been growing over the last decade is designed to be messy. Not as a failure, but as a feature. These tags are not rigid definitions; they’re handles – entry points into ongoing conversations. They hold space rather than close it down. Different people can use the same tag slightly differently, argue over it, stretch it, even misuse it. That friction is not a bug. It’s the composting process.

This is where the #geekproblem shows up hard. The default technical mindset is to treat language like code: define variables, eliminate ambiguity, enforce consistency. In living social systems, that approach kills more than it fixes. You don’t get clarity – you get dead structure. A taxonomy that excludes instead of invites.

But – and this matters – pure chaos doesn’t work either. If everything is noise, only insiders can hear anything. New people can’t find a way in, and the whole thing collapses into a closed loop. The compost stops producing anything useful. So the question isn’t “mess or order?” It’s how to grow balanced living structures.

Dead structure says: this is the correct meaning, this is the right way to use it, anything else is wrong. Were living structure says: here’s how this is being used, here are examples, come play and meaning emerges through use. That’s the difference between a locked-down platforms and the #openweb. One enforces clarity from above, the other grows understanding from below.

Think of it like ecology. Compost isn’t just random waste – it’s a process. Layers, breakdown, transformation over time. Healthy systems have patterns and flows, but they’re never fixed. Forests change. Rivers shift. Nothing is static, but nothing is completely formless either.

The same applies here we don’t need to “clean up” the hashtag mess. We need to use it better by repeating patterns, so people can follow threads, tell stories that embody the tags, let contradictions surface and be worked through and resist the urge to prematurely close meaning. This is basic #KISS, but it’s a hard lesson. Keep it simple doesn’t mean make it simplistic. it means don’t over-engineer what needs to stay alive.

So yes, the mess has value. It creates space for people to build differently, to step outside the rigid frames of the #dotcons and their algorithmic control. It’s how we hold open a commons instead of collapsing back into platforms.

But remember, if everything is compost, nothing grows. If everything is fixed, nothing lives. #OMN sits in that tension, not cleaning up the mess, not drowning in it – but composting it into something people can actually use to make change.

“Digital sovereignty” is more mess we need to compost

“Digital sovereignty” is more mess we need to compost

The servent of the #nastyfew wispering in the ear of the #deathcult ists liberals

From a #OMN perspective, the mess isn’t just the wording – it’s the ideology embedded in the wording, and how that shapes behaviour over time. “Digital sovereignty” sounds harmless, progressive in a liberal policy context. But if you run this through a #KISS ideological lens, its more mess rooted in control, borders, and authority – concepts historically tied to state power. That’s why it’s so easy for the #mainstreaming crew to reuse the language without friction. When they launch something like a “Sovereign Tech fund,” they’re not inventing a new narrative, they’re tapping into one that was already compatible with their narrow worldview.

That’s the problem we need to keep composting – #mainstreaming language carries “common sense” ideological defaults. So what how can we shovel this mess – Liberals adopt a term to make ideas legible to institutions and funding. But obviously the term carries right-leaning assumptions (control, territory, hierarchy) – assumptions that quietly reshape the thinking and direction of projects. Then right-wing actors step in and feel completely at home using the same language.

At that point, it’s already too much mess, you’re not just “using” the language, you’ve internalised the worldview – “Sovereignty” is about defensive, fear-based framing (“protecting against others”) that clashes directly with #openweb values of networks over borders, trust over control and interoperability over enclosure. Our native world view is commons over ownership, so even if the intent is good, the term pulls thinking in the wrong direction. Its #KISS we need to shift focus from states → to people and communities, from control → to capability, from fear → to empowerment.

But here, #OMN pushes much harder – if you need mainstream policy language to explain what you’re doing, you’re already halfway into the #closedweb logic. The #openweb path doesn’t start from sovereignty, autonomy, or even agency. It starts from something simpler – shared standards, visible processes and trust networks (#4opens). That’s why the #OMN path matters, the more abstract the language gets, the easier it is to smuggle in ideology without noticing.

So what do we do with this mess? Yes, “digital sovereignty” is a dead-end term for open, trust-based politics. Yes, alternatives like “autonomy” are an improvement, but the real work is stepping outside that whole framing, instead of arguing over better words, focus on building systems that demonstrate openness, using language grounded in practice, not policy fashion.

Bluntly, this is mess we need to compost, it’s the normal mess of “blinded” liberals laying the groundwork – unintentionally – by adopting language that was never native to the #openweb. That’s the messy pattern – #OMN keeps pointing at, if you build with messy concepts, you will get messy outcomes. So yes – compost it. And next time, start from cleaner soil please.

The recurring theme is digital & social decay – A “trust collapse” resulting from bad faith and disempowerment online. The Goal is #KISS moving beyond individualistic #stupidindividualism, ” common sense to create a balanced collective, community-controlled alternatives.

The #OMN hashtag story is a shovel to “compost mess” to turn toxic digital decay into valuable, new growth rather than pretending the stinking mess doesn’t exist, the second step is acknowledging that disagreements are not to be avoided but used constructively to build stronger, more empathetic, and more transparent communities.

Do you notice a recurring theme and issue here? Read and use the hashtag story to help compost this.

The hashtag story is messy, that’s the Point

People, Process, and the Myth of Difficulty

What we are doing at #Oxfordboaters is simple, that’s the uncomfortable truth for people who see this as to complex. The core idea – people coming together around shared concerns, communicating openly, and acting collectively – is about as old as human society. There’s nothing technically complex about it, nothing conceptually obscure. Yet in practice, it feels almost impossible.

So where does this friction come from? It’s not the goal, it’s not even the surface the process, most of the time, it’s the people – and, more importantly, the tools and cultures we bring with us. The path we need is simplicity underneath – #Oxfordboaters is doing three things:

  • Sharing information about what’s happening
  • Building a shared understanding of that information
  • Acting together based on that understanding

That’s it, strip away the noise, and that’s the whole system. It’s classic #actavisam: publish, discuss, act. You don’t need layers of management theory or complex governance frameworks to make that work. You need #KISS trust, visibility, and participation.

But we rarely get to operate at this level of clarity, the difficulty creeps in as people bring baggage – Everyone arrives with habits shaped by the #mainstreaming worshipping of the #deathcult that leads to the imposing of unthinking expectation of hierarchy (“who’s in charge?”) and fear of speaking openly (“will this be used against me?”) leading to the desire for control (“we need to manage the message”) this “common sense” mess leads to focus on avoidance of conflict (“let’s keep it positive and not rock the boat”).

    These aren’t individual personal failings, they’re social learned behaviours, that distort simple processes into complicated ones. This mess is amplified by a second “common sense” problem, that the tools we use shape behaviour, the #dotcons platforms we “use” default push us in particular mess making directions:

      • Chat tools fragment conversations into noise
      • Social media rewards reaction over reflection

      Instead of supporting collective clarity, these default tools amplify confusion, they make it harder to see what’s actually going on, and thus easier for misunderstandings to spiral. One tool we have is process but is it a tool or weapon? Process can either help people work together, or it can be used to block this work. Some processes are designed to:

      • Encourage participation
      • Make decisions visible
      • Build shared ownership

      Others – often unintentionally – end up:

      • Slowing everything down
      • Creating gatekeepers
      • Hiding power behind “procedure”

      You can see this easily when something urgent comes up – healthy process helps people respond quickly and collectively, were a broken one turns into endless discussion, deferral, and inaction. Same situation, same people – different outcome depending on the process.

      At #Oxfordboaters, the work itself is straightforward: There’s an issue affecting the river community – People gather information about it – That information is shared – A response is organised. But what makes it hard? People are different – Disagreements about tone (fluffy vs spiky), uncertainty about who should act and fragmented communication across platforms leading to #blocking of action.

      None of these are about the actual goal, they’re all about how people relate to each other and the structures they’re working within. The illusion of complexity is one of the biggest traps – mistaking this friction for complexity. When something feels hard, we assume the solution is to add more structure, more meetings, more rules, more #dotcons tools. But this “common sense” push to often adds another layer of blockage, it treats the symptoms, not the cause.

      The reality is harsher the system is simple, but we as a community are messy. So how can we work better in this mess? The answer isn’t to eliminate the mess – that’s impossible. It’s to design processes that work with it instead of work against it. That means accepting disagreement as normal, making conflict visible rather than suppressing it. Keeping structures lightweight and adaptable, in the end it’s about prioritising clarity over control. In #OMN terms, this is where the #4opens come in:

      Open data → everyone can see what’s happening

      Open process → decisions aren’t hidden

      Open source → tools can be adapted

      Open standards → systems interconnect

      These don’t remove human complexity, but they can mediate it from becoming opaque and blocking. So what do we mean by blocking vs enabling. You can tell the health of a project by a simple test – Does the process help people act, or stop them from acting? If people feel empowered to contribute → the process is working. Hesitant, confused, or sidelined → the process is blocking.

      At #Oxfordboaters, like many grassroots efforts, both dynamics exist at the same time. That’s normal. The work is to shift the balance toward enabling. So the hard truth is this the challenge isn’t building the perfect system, it’s growing the relationships that allow the #4opens path to function. That’s slower, messier, and far less comfortable than designing a neat process diagram, but it’s the only thing that actually works.

      Keep it simple (#KISS) – when things get messy, the instinct is to add complexity. The better move is usually the opposite by striping things back to focus on what actually needs to happen. Make it easier for people to take part, because underneath all the noise, the work is still simple. People, talking to each other, deciding to act. Everything else is either helping that – or getting in the way.

      What we’re growing at Oxford Boaters is simple

      From the towpath at dawn to moonlit moorings at dusk, Oxford’s boating community is not a curiosity, it’s part of the city’s living fabric. Generations of people have chosen to make their homes on the water, creating a culture rooted in community, care, and independence. This is a quieter Oxford, rarely captured in guidebooks but felt by anyone who walks the river or canal: a human-scale world of shared tea, passing conversations, and everyday presence. In a city shaped by wealth and exclusion, the river remains one of the few places where real social diversity still exists, where people live side by side not because of status, but because they’ve chosen a different way of life.

      This matters because the boating community doesn’t just live on the river, it sustains it. Their daily presence keeps the towpath safer, more welcoming, and alive. They act as informal stewards, noticing changes in the water, caring for the banks, and maintaining a relationship with the environment that no institution can replicate. Remove this community, and you don’t just lose homes, you lose Oxford’s character, its openness, its lived connection to the river. The waterway becomes quieter, more managed, less human. What looks, from a distance, like a marginal issue is in central, a question of whether #Oxford remains a living city, or becomes more controlled, polished and diminished.

      Exchange CRT for EA its the same story.

      How can we protect that space?

      We want to protect a shared space, keep the river livable, and organize ourselves to have a voice. None of that is technically complicated, the difficulty isn’t the goal, it’s the people, and the tools we use to try and work together. No matter what process we choose, it always comes back to the people who make it work, or the people make it stall. Some processes recognise this and work with human reality – trust, conflict, misunderstanding, ego, care. Other processes ignore it, and end up being used (consciously or not) as blocking. Let’s look at a few grounded examples of this.

      We’ve already seen this clearly, in a face-to-face meeting (the “whispering fire”), trust rises fast. People read each other, soften, find common ground. You can go from 50% to 70–90% trust in a couple of hours. Move the same conversation to online chat, and trust collapses. Tone gets lost, small disagreements escalate, and people start pulling things apart. You drop to 20–30% trust, sometimes lower. Completely different outcomes, it’s not a failure of individuals, it’s a mismatch between tools and human communication.

      The website vs the chat is another clear split. The website (or any structured space) holds higher trust, but lower participation. The chat holds high participation, but low trust – knowledge isn’t captured properly, decisions aren’t visible and new people can’t easily get up to speed. Result: constant rehashing, frustration, and burnout leading to momentum loss.

      There’s a temptation to design the perfect structure with formal agendas, strict procedures and detailed governance. On paper, this looks like progress, in practice, it becomes a brake. As people use “hard” process to delay decisions (“we need another meeting”), avoid responsibility (“that’s not my role”) and assert control (“this isn’t the proper channel”). Instead of enabling action, the process becomes a gatekeeper, leading to the same basic issues resurface again and again. Not because people are stupid, because the basic social fabric isn’t being maintained.

      Processes that work can see this cycle and design around it so as not to keep restarting from zero. So what actually works? The path isn’t finding a “perfect” process, it’s choosing #4opens processes that fit people as they are. That usually means prioritising face-to-face (or close equivalents) for trust building. Keeping structures simple (#KISS) so they don’t become tools of control. Capturing shared knowledge clearly (FAQ, summaries, decisions). Accepting mess as normal, but making sure it composts rather than festers. Balancing fluffy and spiky – you need both to move forward

      And most importantly recognizing that process is never neutral, every structure we put in place will either help people collaborate or give them ways to block each other. Often both at the same time. So yes, what #Oxfordboaters is trying to do is on the surface easy, but what makes it hard is human complexity, mismatched tools and blinded pushing processes that don’t align with either. When we get those bits even slightly more right, everything else becomes possible.

      If we don’t, even the simplest goals turn into a grind, that’s the real work.

      Closed systems protect individuals, but they rarely build movements
      Trust and fear – the spiky/fluff debate – OxfordBoaters

      Closed systems protect individuals, but they rarely build movements

      People fight against or/and ignore the #KISS (Keep It Simple Stupid) approach in tech because simplicity exposes power. Complexity, jargon, and process give cover – they make control look like competence. When paths are simple and transparent, everyone can see who’s blocking, who’s hoarding, who’s acting in bad faith. Many “experts” and institutions are emotionally and professionally invested in keeping things complicated; simplicity threatens their authority, their funding, and their identity.

      All the #OMN projects are not directly about social change – they’re about making social change possible. That distinction matters as people don’t step into change unless they first believe change can happen. If the world feels fixed, locked, inevitable, then nothing moves. Our role is simpler, and maybe more important, to open that door a crack, to show that different paths exist.

      Think of #OMN as a helping hand, not dragging people forward, not telling them what to do – just making it easier for them to take that first step when they’re ready. But to do this, we need to think more clearly – and more fundamentally – about technology itself. As most of the current “open paths” are cosplay at best, we need a network that links them as flows for there use to be unlocked from the current limits of #stupidindividualism shaping them – to become a native part of the expanding #openweb reboot.

      I’ve been working on this for over 20 years, and one thing keeps proving true: we need roughly 90% open and 10% closed, the balance matters. As the current push from the #encryptionists flips this – aiming for 90% closed and 10% open. That isn’t a solution, it’s a retreat. It breaks the social fabric that makes collective tools usable and meaningful. It fragments, isolates, and ultimately shrinks the space where shared culture can exist.

      Yes, privacy matters, yes, some things should be closed, that’s the 10%. But the commons – the space where we meet, talk, organise, and build trust – has to be open. Without that, there is no network, just silos. Take a simple example: you’re reading this via #activitypub. That’s a system built on being mostly open, with just enough closure to function safely. And it works, people are here, conversations happen, networks grow.

      Compare that to more closed, encryption-heavy systems like old school Diaspora. Technically interesting, sure, but socially? Empty, few people, little flow, no impact. That’s the core point: this isn’t just about functions or features, it’s about culture.

      Open federated, networked systems create the possibility of shared culture, and from that, the possibility of social change. Closed systems protect individuals, but they rarely build movements. We need both – but we need to get the balance right. Right now, too many people are getting it the wrong way round.

      This Isn’t New: Decentralisation Was the Point All Along

      Decentralised servers – what we now call the #Fediverse – are often talked about as if they’re some new, radical innovation. They’re not, they’re a return to the original design of the network. The early internet wasn’t built to be controlled, it was built to survive. The core idea was simple: if parts of the network were destroyed – even something as extreme as a nuclear strike – the rest would keep functioning. No centre, single point of failure or “off switch.”

      That’s what decentralisation actually means. And this thinking didn’t even start with the #openweb. Systems like Usenet already embodied this approach: distributed, federated, run by many, owned by none. Messy? Yes. But resilient, open, and hard to capture.

      What we’ve been living through for the last 20+ years – the rise of the #dotcons – is the opposite of this. Centralised platforms with single points of control. Easy to use for control and monetise, easy to manipulate, easy to shut down. We didn’t lose the #openweb by accident, we blindly traded it away for this convenience.

      What we’re seeing now with the #Fediverse, #ActivityPub, and related projects isn’t innovation in the common sense. It’s a reboot, a return to the path we were on before we derailed it. The difference is that now we’re trying to rebuild this in a world that has spent decades normalising centralisation and control. 40 years of death cult worship has changed people, institutions, social groups and our very internal selves. That’s where the friction comes from, people arrive expecting #dotcons platforms, what they find is networks. People expect control, what they get is responsibility. People expect “free” what they face is shared cost and care.

      So, it was never about the tech, the mistake we keep making is ONLY thinking this is a technical shift, it’s not, it’s cultural. You can spin up a decentralised server in minutes, that’s not the hard part, the hard part is everything around it:

      • Who runs it
      • Who pays for it
      • How decisions are made
      • How conflict is handled
      • How trust is built and maintained

      This is the work the #dotcons hide from us, they wrap control as “free services” paid for with surveillance, extraction, and control. Now that we’re back on the #openweb path, that work becomes visible again, and yes – it’s harder.

      Why this matters (Again). Resilience isn’t an abstract idea anymore as we’re living through cascading crises: political instability, #climatechaos, infrastructure fragility. A centralised network fails catastrophically were a decentralised network degrades – but keeps going. That’s the difference between a system you depend on and a system you can trust.

      We don’t need to overcomplicate this – Keep It Simple (#KISS)

      One builds commons, the other extracts value, everything else is detail. And yes nobody thinks the Fediverse is not messy, uneven, (yet) match the polish of corporate platforms. That’s fine, mess is where growth happens – if we compost it properly.

      The #OMN view, we’re not trying to invent something new. We’re trying to make what already works usable at scale for media, trust, and collective action. The infrastructure is there, the protocols exist, the history is long. What’s missing is the shared layer – the commons – where information flows in ways people can actually rely on, that’s what we’re building.

      If decentralisation feels radical, it’s only because we’ve spent so long inside systems that forgot #OMN #openweb #KISS

      Trust and fear – the spiky/fluff debate – OxfordBoaters

      People fight against or/and ignore the #KISS (Keep It Simple Stupid) approach to social movements because simplicity can expose power. Complexity gives cover, making control look like competence. When paths are simple and transparent, everyone can see who’s blocking, who’s hoarding, who’s acting in bad faith. Many “experts” and institutions are emotionally and professionally invested in keeping things complicated as simplicity threatens their authority and their identity.

      As second step in change and challenge we need to face some uncomfortable roots: fear of death, fear of the “other.” Fear, as the man said, is the mind killer. Too few people trying to change the world bother to look at the psychological ground they’re standing on. Our social mess isn’t random, it grows from somewhere. If we don’t deal with the roots, we just keep trimming the leaves and wondering why the weeds grow back.

      At the centre of this is trust, it is what makes social change possible. It’s the messy, ongoing tussle between horizontal and vertical forces, between collective process and imposed control. Take Oxford boaters as a lived example, this is observational, based on 40 years of doing this kind of work.

      Face-to-face meetings? They start at maybe 50% trust and can rise to 70% without too much trouble. That’s because the people who show up are self-selecting – a mix of fluffy and spiky, but open enough to engage. You get debate, but also movement.

      Then we go back online were trust drops fast – down to 20–30%, sometimes even into negative territory. That becomes the dominant tone as things splinter. Work that was built collaboratively offline gets pulled apart, the focus doesn’t hold.

      On the open collective website, trust is actually high – but usage is low, again, self-selecting. So rollout stalls, no shared space, no shared understanding, no momentum.

      So we call another face-to-face, the “whisper fire.” Trust shoots up – 90%, easy. People align, decisions get made, it feels like progress. But then everyone goes home, the next day? Momentum evaporates, as few people feel responsible for carrying things forward. And very quickly, we slide back into the low-trust dynamics of online chat.

      Meanwhile, the group has grown, more people from offline outreach and leafleting. But the website is still stalled, so there’s nowhere to hold shared knowledge. We keep re-arguing basics, we don’t even have a solid FAQ. Trust drops again.

      Next meeting: bigger pool, smaller turnout. Trust starts at near zero, the first half is rough – people filtering out, clashing, posturing. Slowly, some shared ground emerges and trust crawls up to maybe 50% but still, nothing concrete gets resolved. A few working groups are seeded. Environment sort of functions. Media splinters from the start, but manages a press release, but without any clear #4opens process. Beyond that, the next steps remain unanswered.

      Back online? Trust gets ripped apart again. The whisper fire is supposed to be every week, but we have lost focus, but we try agen – half-heartedly at first. Poor turnout, then people drift in after a couple of hours. Trust rebuilds to around 70%. Real decisions get made, consensus emerges, it starts to feel like an actual working affinity group.

      But the chat? Still toxic, low trust, constant tearing-down, fixation on side issues, and a push toward rushed bureaucratic structures that crumble under their own weight. The only thing that actually works is the consensus built in the whisper fire – because that’s what people really agree on, underneath the passive-aggressive noise. But after each cycle, trust in the online chat drops again, down below 30% on the surface. Maybe 40% underneath, if you’re generous.

      And now we hit the next stage: formal process, bureaucracy, decisions that actually matter, where it gets real. And because online trust is still so low, everything becomes harder than it needs to be, friction everywhere, misunderstanding as default.

      But – and this is the hopeful bit – offline trust is slowly growing. So maybe, just maybe, we can carry that through, if we don’t let the chat tear it apart first.

      Individual fears
      So how do we mediate this fear?
      Process is what gives legitimacy

      #OxfordBoaters

      We keep making mess, then wondering why everything smells

      A big part of this is the language we use, when we unthinkingly spread #mainstreaming terms, we push the worldview that comes with them, and that worldview is usually rooted in fear, control, and market logic.

      Take “digital sovereignty.” it sounds solid, sensible, progressive. But, it’s a made-up term trying to frame the internet in nation-state and market terms – ownership, borders, competition. It’s a liberal answer to a fear-based economy: “how do we control this thing so it doesn’t threaten us?” That framing is the problem, because the #openweb was never built on control. It was built on trust, shared standards, and open process – the #4opens:

      • open data
      • open source
      • open standards
      • open process

      That’s the native soil, when we blindly shift to language like “sovereignty,” we drag in assumptions that don’t belong. We start thinking in terms of ownership instead of participation, control instead of collaboration. And that creates mess – conceptual, political, and technical Then we spend years trying to “fix” that mess, composting it.

      But it’s much better if we don’t make that mess in the first place #KISS, by staying grounded in #openweb values. We don’t need to retrofit control structures onto something that was designed to work without them. We don’t need layers of governance theatre to simulate trust, we can build trust directly through open processes.

      This is why clarity, clear language matters, if we keep pushing borrowed language from the #deathcult, we’ll keep rebuilding its logic, no matter how good our intentions are. So yes, we need to talk more clearly about stopping importing broken concepts, stop framing open systems in closed terms and stop making more mess we then have to compost.

      Start from the roots, grow from there, please.

      The #dotcons, #mainstreaming, and Build to Walk Away

      Three years ago I was trying to explain something simple in language liberals might actually hear. They talk about “platform capitalism.” Fine. But I’ve been calling it the #dotcons for 20 years – because that’s what it is – a con.

      The last 30 years of tech hasn’t just drifted into this mess. It’s been shaped, step by step, enclosure by enclosure, into systems designed to extract value from us. What we now call the internet is, in large part, a machine built to manipulate, capture, and profit.

      The old #openweb got fenced in, and most people, especially polite liberal society, went along with it. So we need to talk about the return and the problem. Now we have a shift of the #mainstreaming is flowing back toward the #openweb, that should be a good thing. But there is a problem: people don’t leave the #dotcons behind when they move, they bring the culture with them.

      What we’re seeing is a flood of the same patterns – extractive behaviour, ego performance, status games. Not from one “side,” but from everywhere. The habits built inside the #dotcons don’t magically disappear just because the platform changes.

      So the real issue isn’t technical, it’s cultural. If we don’t actively mediate this influx, we won’t rebuild the #openweb – we’ll just recreate the same broken systems in slightly different code.

      So why do I talk so much about compost, and mess not being the problem. Mess is necessary, but only if it composts – if it breaks down into something fertile. Right now, we’re mostly just piling it higher.

      This is where projects like #indymediaback and #OGB matter. They’re not perfect, but they are native to the #openweb path: grounded in trust, process, and the #4opens rather than control, branding, and capture.

      The question isn’t whether #mainstreaming is good or bad. The question is: how do we hold the cultural line so that what grows is something genuinely different? Because if we don’t, the #dotcons don’t need to defeat us. We’ll blindly rebuild them ourselves.

      So why do I argue we can’t just leave the #dotcons? This is where people get it wrong, every time the #dotcons tighten control – censoring, tweaking algorithms, shifting rules – the reaction is the same: leave, build the #openweb.

      Yes, build the #openweb, but the idea that we should stop organizing inside the #dotcons right now? That’s a trap, because billions of people are still there. The conversations, the communities, the movements, they haven’t magically migrated. Walking away doesn’t free those people, it abandons them, leaving the space to be shaped entirely by the #deathcult and the forces already in control.

      This is #nothingnew. The #dotcons are #closedweb infrastructure. They serve power because they were built to serve power. Expecting anything else is misunderstanding the system. The real question has never been: are these platforms good? It’s: what do we do, given that this is where people are?

      The #geekproblem and the exodus fantasy, is a persistent fantasy – a classic #geekproblem – that if we just build better tools, people will come. They won’t, not on their own. A clean exodus to the #fediverse or any #openweb space doesn’t happen because we post about it. Movement-building has never worked like that, people move through relationships, trust, and shared struggle – not technical superiority.

      So if you abandon the spaces where people already are, you cut those pathways. The #OMN approach has always been simple to use the #dotcons as a bridge, not a home, seed organizing where people already are while focusing energy on building the #openweb in parallel to clearly keep your foundations in the #4opens.

      This isn’t about purity, it’s about effectiveness, don’t fall into #stupidindividualism, the idea that personal withdrawal is more important than collective reach. This is about infrastructure and grounding, if the #dotcons can switch you off at any moment, they cannot be your foundation.

      That’s why we need:

      • indymediaback as publishing roots
      • activitypub and the #fediverse as distributed infrastructure
      • OMN as a bridge between cultures and spaces

      This is the practical expression of the #4opens: not just open code, but open process and open trust. Don’t build your house on someone else’s land, but don’t stop talking to the people still living there either. Stay in the fight, when the #dotcons clamp down, it’s not a surprise, it’s a signal of what they are, and what they’ve always been.

      The answer isn’t to run away, it’s to root ourselves somewhere that can’t be shut down, while continuing to show up where the people are.

      Build the #openweb, stay in the fight, keep it simple #KISS

      Toward Healthier Digital Public Spaces: A Cultural and Structural Challenge

      From a practical perspective, the challenges in digital and social technology are not technical, they are cultural. This may seem obvious, but it is often overlooked in policy and implementation. At a basic level, there are two broad approaches to handling disagreement and complexity in online spaces:

      • Exclusion-focused approaches (e.g. blocking, filtering, silencing), which reduce immediate friction but reinforce fragmentation and polarisation.
      • Engagement approaches (e.g. dialogue, questioning, listening, and iterative response), which are more demanding but can, over time, reduce conflict and build shared understanding.

      In the current mess – shaped by strong norms of individualism and personal optimisation – the first dysfunctional approach dominates. This grows increasingly fragmented discourse, where communities become isolated and less resilient.

      Understanding this we can start to show the limits of “Common Sense” in today’s mess, were governance relies on this “common sense.” Over the past four decades, economic and cultural frameworks – market-driven individualism – has controlled how we design and use digital systems contributing to:

      • Increased social fragmentation
      • Growing economic inequality
      • Incentive structures prioritising engagement over well-being
      • Environmental and social externalities (including visible #climatechaos impacts)

      These outcomes tell us that existing models are not sufficient for building sustainable digital public spaces, so we need to #KISS revisit platform dynamics and structural Incentives.

      The dominant digital platforms (the #dotcons) operate on business models that prioritise data extraction, engagement metrics, and advertising revenue. These incentives shape what information is amplified, how users interact and which behaviours are rewarded. While these systems are effective at scaling control, they are not in any way aligned with public interest outcomes such as trust, accountability, or democratic participation.

      Current trends – ranging from disinformation to polarisation and environmental stress – highlight the limits of systems based purely on competitive, self-interested models. At the same time, alternative approaches – such as the #openweb and federated systems – offer more aligned values but face basic challenges of coordination, usability, and governance. So we need to move from fragmentation to constructive engagement, to reframe the problem, from crisis to stewardship.

      This more sustainable approach emphasises stewardship over extraction, collaboration over isolation to help build resilience over short-term optimisation. This does not mean abandoning innovation or individual freedom, but rather #KISS balancing these with responsibility for shared outcomes. As the current challenges in digital spaces are not only the result of “bad actors” or isolated failures. In simple terms we need to move from systems that amplify division toward systems that support understanding and the common good.

      To compost this mess we need a willingness to engage with complexity and a commitment to building systems (technical and social) that prioritise long-term public value over short-term individual gains. This is not easy work – but it is necessary if digital infrastructure is to support healthy, democratic societies.

      KISS – Keep it simple, sustainable, and focused on the common good.

      EU taking the open web path?

      When thinking about supporting the #Fediverse, it’s important to understand that the current codebase leadership model is closer to an aristocracy than democracy. This isn’t unusual – most open source projects work this way. A small group of core developers, often a “benevolent dictator,” make key decisions. This model can work up to a point: it enables speed, coherence, and technical direction. But it does not scale in any way easily into a broader public infrastructure.

      From the outside, the #Fediverse can look chaotic, and in many ways it is. A useful metaphor is an elephant stampede with people throwing paper planes at each other. That messiness is not a failure; it’s a reflection of a genuinely distributed system.

      Democracy is inherently messy.
      Bureaucracy, by contrast, is tidy.

      The tension between those two is at the heart of the challenge outreaching to public institutions faces. Traditional organisational models – especially those involving funding – tend to concentrate power. Once money and status enter the system, decision-making quickly becomes a focus of competition and control.

      We have seen this repeatedly over the last 20 years: projects that begin open and collaborative gradually centralise, and in doing so lose the qualities that made them valuable in the first place. If the goal is to support a native Fediverse ecosystem, this pattern needs to be consciously avoided.

      This raises a governance question. How are decisions made once resources, funding, and institutional recognition enter the space? Without deliberate design, the default outcome is oligarchy – small groups making decisions on behalf of many. This is not only a moral failure; it is a structural tendency of complex organisations.

      The strength of the #Fediverse is that it is radically different from mainstream platforms. It is decentralised, diverse, and resistant to single points of control. The risk is that, in mainstreaming paths trying to support it, we unintentionally reshape it into something more familiar, and less effective. “Common sense” approaches, based on traditional institutional models, push in this direction. If European institutions want to invest meaningfully in this space, the challenge is not simply technical. It is cultural and organisational:

      • How to support infrastructure without centralising control
      • How to enable coordination without enforcing uniformity
      • How to fund development without creating capture points for power

      The opportunity is significant, but it requires seeing and recognising that the #Fediverse works because it is different – and ensuring that support mechanisms strengthen that difference, rather than smoothing it away.

      The value of the #Fediverse comes from its cultural roots in the #openweb

      Beyond Blocking: Building Trust Infrastructure for the Open Web

      A Policy Case for Commons-Based Moderation in the Fediverse

      The problem with the current approach

      The normal response to harmful content and behaviour on federated social platforms today is the block. Instance administrators block other instances. Users block other users. Communities build blocklists and share them. This is understandable – it is the tool available – but it is not a solution. It is, at best, a temporary containment strategy.

      Blocking is the digital equivalent of closing the curtains. The problem does not go away. The harmful actor does not change. The tension, between open participation and community safety, between freedom of expression and protection from harm, is not resolved. It is deferred, and at a cost to the openness that makes the Fediverse worth defending in the first place.

      When entire instances are blocked, legitimate users on those instances lose access to communities they value. When blocklists are the primary moderation infrastructure, the communities that maintain them acquire disproportionate power over what the network sees. The default is isolation, the Fediverse fragments, not because of any external threat, but because of its own defensive reflexes.

      This matters beyond the technical community. The Fediverse represents the largest functioning alternative to corporate social media. It is, in the most literal sense, public digital infrastructure owned by nobody and available to everyone. How it handles the tension between openness and safety determines whether it can scale to serve democratic societies, or if it remains a technically interesting experiment for a self-selecting community.

      The #4opens principle and why it matters for policy

      The Fediverse is built on a set of principles called the #4opens: open data, open source, open standards, and open process. These are not just technical preferences, they are a statement about what public digital infrastructure should look like – transparent, accountable, forkable, improvable by anyone.

      The fourth open – open process – is the most politically significant and the most underdeveloped. It means that governing our communities, including how we handle conflict and harm, should be visible, contestable, and collectively grown. Not handed down by a platform’s trust and safety team or enforced by an opaque algorithm, not dependent on the goodwill of a instance administrator.

      The current state of Fediverse moderation largely fails this test. Moderation decisions are made locally, inconsistently, and without shared infrastructure for collective reasoning. The result on balance is less freedom, more a patchwork of micro-kingdoms, each with its own rules, enforced by blocking the kingdoms whose rules they disagree with. This is not a stable foundation for the kind of digital public sphere that European democratic values require.

      The commercial platforms are not the solution – but they are in the room talking loudly

      Commercial social media platforms – what we call the #dotcons, shorthand for the dot-com era corporations that monetised public digital space, are present in or adjacent to the Fediverse. Meta’s Threads now implements ActivityPub, the protocol underlying Fediverse federation. This means that the same open standard that allows community-run instances to talk to each other also allows a platform with three billion users and an advertising-driven engagement model to participate in the same network.

      The response in parts of the Fediverse community has been, predictably, to block Threads at the instance level. This is coherent as a local decision. As a strategy for the #openweb, it is kinda self-defeating. Blocking Meta does not make Meta go away, it does not change Meta’s incentives. It does not protect users who remain on Meta from the harms of algorithmic amplification. And it does little to build the alternative infrastructure that would give those users somewhere better to go.

      The principled response to commercial platform encroachment on the openweb is not isolation, it is to build commons infrastructure so robust, so trustworthy, and so genuinely useful that the value proposition of centralised platforms diminishes. That means solving the moderation problem properly, not routing around it.

      What trust-based flows offer that blocking cannot

      The research and development work at projects like the Open Media Network (#OMN) points toward a different model: moderation not as exclusion but as flow management. In a trust-based flow architecture, content does not move through the network based on algorithms optimising for engagement, nor is it blocked at the border by administrators making binary decisions. Instead, it flows – or slows, or stops – based on trust relationships that communities build and maintain themselves. Trust is local, it is composable, different communities will apply different trust filters to the same content without requiring global consensus or any centralised authority.

      This model has several properties that should interest European policymakers directly:

      Accountability without centralisation. Trust relationships are explicit and auditable. When a community decides not to propagate certain content, that decision is visible and contestable within the community. This is categorically different from both corporate content moderation (opaque, unaccountable) and simple blocking (binary, irreversible).

      Resilience against capture. Because trust is distributed and local, there is no single chokepoint that a bad actor – commercial, state, or otherwise – can capture to control information flows across the network. This is critical infrastructure resilience in the same sense that distributed energy grids are resilient against single points of failure.

      Reversibility. The rollback function – the ability to re-evaluate historical content visibility based on updated trust relationships – is something no current platform offers at scale. It means that moderation decisions can evolve as communities learn, rather than being permanently encoded in block lists that few people maintain.

      Scalability without hierarchy. Top-down moderation breaks down as communities grow. Moderators experience burnout and trauma. Rules based decision making become inconsistent. The trust-based model scales horizontally – as the network grows, the trust infrastructure grows with it, because it is built into the relationships between nodes rather than concentrated in any central authority.

      The culture question is not separate from the technical question

      It is a constant mistake to read this as purely a technical, you cannot build a healthy online culture without infrastructure – and you cannot build the working infrastructure without clear visions of what culture looks like.

      The Fediverse community is currently navigating this without adequate tools. The result is a recurring cycle: a wave of new users arrives, often fleeing a crisis on commercial platforms. The existing community debates how to handle them. Blocking becomes the instrument of cultural negotiation. Fragmentation follows. The cycle repeats.

      What is needed is not better blacklists, we need infrastructure that makes constructive engagement the path of least resistance, where trust can be extended incrementally, withdrawn proportionally, and rebuilt over time. Where communities are not forced to choose between openness and safety because the tools exist to manage both simultaneously.

      This is a social and political problem that has a technical component. The Open Media Network project is one concrete path to solving it, building on mature existing infrastructure, proven open standards, and a decade of practical experience in grassroots on the ground and online federated media.

      What European public investment can achieve here

      European public funding for digital commons infrastructure has a strong track record. The NGI Zero programme has supported foundational work on everything from secure routing protocols to private messaging to federated video platforms. This investment compounds: open source outputs are reused, extended, and built upon by developers and institutions across the continent and beyond.

      The case for investing in trust-based moderation infrastructure for the Fediverse is straightforward as the problem is real, well-documented, and getting worse. The Fediverse is growing, but without better tools for managing harmful content and building coherent information flows, its growth will hit a ceiling defined by the limits of volunteer moderator capacity and the inadequacy of binary blocking as a governance tool.

      The solution is technically tractable, the components exist, the protocol exists, the codebases exist, the community exists. What is missing is the focused R&D investment to implement trust-based flows as working, deployable, open infrastructure.

      The alternative is worse, if the Fediverse fails to solve this problem, the vacuum will be filled either by commercial platforms extending their reach into the federated space on their own terms, or by the continued fragmentation of the #openweb into isolated communities talking only to themselves. Neither outcome serves European democratic values or European digital sovereignty.

      The investment required is modest. The upside, is a functioning commons layer for federated media distribution, owned by nobody, available to everyone, accountable to the communities it serves, is large. The time to build it is now, before the structural problems of the current moment ossify into the permanent architecture of the next generation internet.