The #OMN Framework: The Five Functions (#5F)

The Open Media Network (#OMN) is not a platform, it’s a human-scale, federated media infrastructure built on #FOSS practices and the #4opens:

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

It doesn’t start with features, apps, or ideology, it starts with flows.

Think in Flows, Not Platforms

Imagine the network as:

pipes and holding tanks

Content (objects) flows through them, communities decide how that flow is shaped. Nothing magical, nothing hidden. This matters because:

If people can’t picture how a system works, they can’t govern it.
And when systems become opaque, power centralises.

So #OMN reduces everything to five simple functions:

1. Publish

(Add a drop to the flow)

Publishing is simply adding an object:

• a story
• a post
• media
• data

to a stream.

• No automatic amplification
• No built-in authority
• No algorithmic boost

Publication is contribution, not domination.

2. Subscribe

(Connect the pipes)

Subscription is how flows connect:

• people
• groups
• topics
• instances

This replaces:

• platform logic → “you are inside us”
  with
• network logic → “this connects to that”

No opaque ranking, you decide which pipes you connect.

3. Moderate

(Filter and route the flow)

Moderation is not censorship. It’s sieving.

Flows can:

• pass through
• be filtered
• be slowed or prioritised
• be contextualised

Trust is:

• local
• visible
• reversible

Different communities can apply different filters to the same flow.

This is a feature, not a bug.

4. Rollback

(Drain and reset the flow)

Rollback is how systems recover:

• remove past content from your stream
• undo aggregation decisions
• correct mistakes
• respond to abuse

Without rollback:

• errors become power struggles

With rollback:

Accountability becomes procedural, not punitive.

5. Edit Metadata

(Shape meaning downstream)

Content is not rewritten – it is contextualised.

Metadata can include:

• tags
• summaries
• trust signals
• warnings
• translations
• relationships

This is where meaning is created.

Not by algorithms, but by people.

The Holding Tank

Underneath it all is:

a simple storage layer

• a database
• stored objects
• moving through flows

No “AI brain” or hidden feed logic, just data shaped by social processes.

Why This Matters

Most current systems bundle everything together:

• identity
• publishing
• distribution
• moderation
• monetisation

This creates centralised control, even when systems claim to be “open”.

OMN does the opposite:

It separates the core functions.

This makes the system:

• understandable
• auditable
• forkable
• governable

#NothingNew by Design

This model isn’t new, it mirrors systems we already understand:

• plumbing
• electrical grids
• packet-switched networks
• version control

That’s intentional.

Systems people understand are systems people can govern.

From Platforms to Commons

The #5F is the smallest possible set of actions needed to run a media network:

• Publish
• Subscribe
• Moderate
• Rollback
• Edit

Everything else:

• feeds
• timelines
• notifications
• UI/UX

…is just interface, nice to have but not essential.

The Point Is – The OMN is not about building a better platform.

It’s about building:

infrastructure for a democratic digital commons

Simple flows.
Social mediation.
Human control.

Not control systems, but trust systems.

In One Line

#OMN is plumbing for the #openweb. #KISS

To simplify the Open Media Network (#OMN), we focus on its core goal: creating a human-scale, community-governed media infrastructure that isn’t controlled by big corporate platforms. As we outline to understand and “simplify” the #OMN is to look at its five irreducible functions:

The 5 functions reduces networked publishing to just five basic actions. Everything else – like your feed, notifications, or dashboard – is just the interface.

• Write: Creating the content.
• Tag: Categorizing it, so others can find it.
• Publish: Making it available on the web.
• Federate: Sharing it across different trusted networks.
• Archive: Ensuring it remains accessible over time.

The “#4opens” Framework is built on four principles designed to keep power in the hands of users rather than central authorities:

• Open Data: Information belongs to the community.
• Open Source: The code is free to see and change.
• Open Process: Decisions are made transparently.
• Open Standards: Systems can “talk” to each other without gatekeepers.

Key Concepts for Simplification

• Keep It Simple (KISS): The system should be so simple that anyone can mentally model how it works. If it’s too complex to understand, it’s too complex to govern.
  
• Social over Technical: Prioritise how people use the tools over how “elegant” the code is, to mediate the #geekproblem (tech that’s too hard for normal people to use).
  
• Composting the Past: Instead of starting from scratch or repeating old mistakes, the #OMN is about taking the “wreckage” of previous projects and turning them into “fertile soil” for new, federated networks.
  
• Trust-Based Networking: It moves away from global algorithms and toward small, connected “nodes” of people who trust each other.