DRAFT (this one need a edit)

In every activist space, grassroots project, every loose collective, you get people who bring mess in the wrong way – sniping, backbiting, constant undermining. Call it ego, trauma, status games, burnout… it doesn’t matter. What matters is, this friction is normal, it’s part of the #mess we can’t avoid. The mistake is thinking we can eliminate it. You can’t, but you can design for it. That’s where the #OMN path is useful: don’t try to “fix the people,” build processes that compost the behaviour instead of letting it rot the group.

What we need to activly compost is that anything that starts as a real idea – community, freedom, or independence – gets picked up, processed, and turned into something hollow. Not just by “the other side,” but by the entire modern media and tech machine. Good ideas go in, slogans come out, you’ve seen it: “freedom” becomes branding, “community” becomes marketing and resently “sovereignty” becomes a funding pitch.

This is the trap, when ideas get flattened into talking points, they stop doing anything real. They become easy to repeat, to weaponise and impossible to build with. And once that happens, it doesn’t matter who started the idea, it’s no longer yours. So the question isn’t only left vs right. It’s how do you keep ideas grounded so they can’t be hijacked and sold back to us?

One answer is structure, the #4opens approach is simple, a way to stop things being quietly twisted behind closed doors. If you can see how something works, it’s harder to fake, if you can take part, it’s harder to capture.

The other answer is mess (the good kind), the #OMN hashtag approach doesn’t try to clean everything up into a single message. It keeps things local, contextual, a bit rough around the edges. That “mess” is protection, because systems that are too neat, too polished, too uniform… are exactly the ones that get captured, repackaged, and pushed back at you.

In plain terms if an idea can be turned into a neat slogan, it can be taken over. If it stays tied to real people, real places, and real processes, it’s much harder to fake. This is the difference between something you can live with and something that gets sold to you. Call it compost if you like – You break things down, keep what’s real, and grow from that.

One example: 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.