Together we are assembling an open Knowledge Commons Toolkit. Not building a platform. Not debating theory. Pooling what exists, making it legible, mapping how parts connect, and packaging it so any community can pick it up and put it to use. By the end of two days, we make it real.
A knowledge commons is a collectively maintained body of knowledge — composed of the playbooks, primitives, protocols and utilities that communities use to organize, share, and govern information. Unlike a platform owned by one entity, a commons is stewarded by its participants, designed to be composable, modular, and interoperable.
A swarm is a time-bound convening where participants work in parallel on a shared output — following their energy, switching between moves freely, and surfacing collective intelligence through rhythmic syncs. There are no assigned tasks. No presentations. No panels. Everyone contributes however they choose. A shared activity feed makes contributions visible. This swarming protocol itself is a reusable template for commons-based collective intelligence and collective action.
The resources that communities need to organize shared knowledge already exist — scattered across networks, projects, and practices. What's missing is the connective tissue: a shared language, a functional map, and composition patterns that let these design choices be understood and pluralistic components connect. That's what we're creating together.
We begin by surfacing what already exists — the utilities, primitives, protocols, patterns, and playbooks scattered across communities and networks. But this isn't a dead inventory we build and discard. It's a living canvas that evolves with the ecology it describes, helping people discover the resources that are already out there and the relationships between them.
From the surfaced landscape, we identify what's underdeveloped, where the seams don't yet hold, and what would unlock new capacity. Together we draft, refine, and prototype the missing parts — sharpening descriptions, naming patterns, and giving the work structure that others can pick up and run with.
The coherence we develop together is only valuable if others can build on it. We leave this experience having published a tangible guide, map, index and wizard — practical artifacts that help any community navigate the landscape, compose their own knowledge commons, and contribute back to the living ecology we've seeded.
Four interconnected pieces, designed together over two days. Each feeds the others. Together they form a published package any community can use to navigate, compose, and extend a knowledge commons from open, modular parts.
A living canvas of every component surfaced during the swarm — organized by function, described by what it does, with connections drawn between parts. Not a whiteboard that gets erased, but a permanent reference that evolves with the ecology it describes.
An interactive tool that guides everyday people through the process of composing a knowledge commons in a specific context. The wizard should trace a path through the functions, explain how the choices connect and what to watch out for. Different starting points, same shared landscape.
The conceptual frame that makes everything else navigable. What is a knowledge commons? What are its parts? How does this toolkit work? How do you start? Read this first, then use the map and wizards with confidence.
Every component indexed with structured metadata — function, affordances, limitations, connections, and openness. The searchable, relational backbone that makes the toolkit a living resource rather than a static document. This open source asset helps builders and communities discover and connect their pieces.
Six questions frame the functions and scaffold the map. Each function holds plural options — not one right answer, but a landscape of approaches with different affordances and tradeoffs. Under each function, many options sit side by side so communities can choose what fits their context.
Where does the knowledge live?
How does knowledge get in?
How do people discover what's there?
Who decides what and how?
How does it talk to other systems?
How does it learn, version, and improve?
These intentions guide how we work during the swarm and what values the toolkit embodies. They are not rules — they are orientations that shape our choices about what to surface, how to describe it, and what to prioritize.
Pool what already exists and describe it by what it does, not who made it. Use functional language so anyone can navigate the landscape without insider knowledge. No one starts from scratch.
Name lock-in and design around it. Map the open alternatives, then draw the connections between parts — how they interact, what emerges when you compose them. The relationships are the intelligence.
Sharpen what exists, fill in gaps, and build the feedback loops that let the commons learn from itself. Usage signals, peer review, decay and renewal. A living commons is one that keeps getting better.
The relationships between the people doing this work are the real infrastructure. Strengthen bonds at the center and tend the edges — the overlooked contributors, the adjacent communities, the approaches not yet in the room.
These are the actions available to you during any open working time. You can do one or more. Switch freely. Follow your energy. There is no assigned sequence — you move between them as your curiosity and the swarm's needs dictate. Each move feeds different parts of the shared output.
Identify a component and add it to the index. It can be something you built, something you use, something you've heard of, or something a peer mentioned. The point is to surface it — make it visible within the toolkit. Go one step further and place it in a function within the map.
Pick a card already placed on the map and make more understandable. A scouted card might be a stub — just a name and a function. Crafting means filling in the details: what it affords, what it doesn't, what it depends on, what it plays well with.
Find someone and start a conversation. Share what you're seeing, ask what they're working on, explore what you have in common. The swarm is as much about the relationships between people as the relationships between components.
Take a path through the functions — one or more options per function — and write a path for the assembly wizard. A good wizard tells a coherent story: context, need, configuration, outcomes, and what to watch out for.
Document what's happening. Capture the story of the swarm itself. Write up insights, capture the map at different stages, narrate the arc. The harvest turns a working swarm into a meaningful origin story.
Not building one platform — we're mapping the landscape of options so communities can choose what fits
Not picking winners — every card is described by what it does, not ranked against alternatives
Not defining the one true architecture — there are many valid paths through the functions
Not asking anyone to abandon what they've built — we're surfacing and connecting, not replacing
Not an unconference, hackathon, or pitch fest — this is coordinated, output-driven collaborative work
Every move feeds the collective intelligence. The map is the shared artifact — source material for a published, permanent package
Swarms are open. You do what calls you. Follow your energy. Switch moves freely. Nobody is assigned tasks
Attribution on the back, not the front. Nobody leads with their brand. Every card described by what it does
The format itself is a reusable pattern. Swap the domain. The functions shift. The moves stay. Run it again for any commons
Syncs are where collective intelligence surfaces — short, rhythmic moments of shared awareness between open working blocks
Step in and start participating — get onboarded into the the toolkit blueprint, schedule, working tools, and everything you may need. Pick a move, find a function, follow your energy.
Your working environment. Pick a tab. Pick a move. Follow your energy. Everything you do here feeds the toolkit.
Four interconnected artifacts, compiled together over two days. Track how the blueprint is filling in as the swarm progresses.
A living canvas of every component surfaced during the swarm — organized by function, described by what it does, with connections drawn between parts. Not a whiteboard that gets erased, but a permanent reference that evolves with the ecology it describes.
An interactive tool that guides everyday people through the process of composing a knowledge commons in a specific context. The wizard should trace a path through the functions, explain how the choices connect and what to watch out for.
The conceptual frame that makes everything else navigable. What is a knowledge commons? What are its parts? How does this toolkit work? How do you start? Read this first, then use the map and wizards with confidence.
Every component indexed with structured metadata — function, affordances, limitations, connections, and openness. The searchable, relational backbone that makes the toolkit a living resource rather than a static document.
A living canvas of every component surfaced during the swarm, organized by function. Each function holds the scouted, crafted, and connected components — and the lines between them reveal how the parts compose.
Where does the knowledge live?
How does knowledge get in?
How do people discover what's there?
Who decides what and how?
How does it talk to other systems?
How does it learn, version, and improve?
Guided walkthroughs for composing a knowledge commons in a specific context. Each wizard traces a path through the functions and explains how the choices connect.
The assembly wizard is a CLI plugin you install from GitHub. It walks you through composing a knowledge commons for your specific context.
$ npm install -g @opencivics/assembly-wizard
View on GitHub →
Wizard crashes when no Store option is selected
Add YAML export option for wizard outputs
Support custom function templates beyond the six defaults
Tab completion doesn't work in zsh on macOS
Allow wizard to read from existing canvas exports
The orienting document. Answers the essential questions: What is a knowledge commons? What are its parts? How does this toolkit work? How do you start? It's the first thing someone reads before using the map or wizards.
Upload markdown, PDF, or docs that should be folded into the instructional guide. Drafts, notes, references, frameworks — all welcome.
or drag and drop here · .md, .pdf, .docx, .txt
knowledge-commons-primer.md
six-functions-explainer.pdf
stewardship-roles-draft.md
composition-logic-notes.docx
Every component surfaced during the swarm, entered into an open source index with proper metadata and relations. The structured, searchable, relational backbone of the toolkit. This might look like:
| Name | Function(s) | Type | |
|---|---|---|---|
| Obsidian Vault | Store | Utility | View |
| Git Repository | Store Evolve | Utility | View |
| Notion Database | Store Find | Utility | View |
| Graduated Stewardship | Govern Contribute | Pattern | View |
| ActivityPub Federation | Connect Contribute | Protocol | View |
| Knowledge Graph | Find Connect | Utility | View |
| Decay & Renewal | Evolve Govern | Pattern | View |
| Hypothes.is | Contribute Find | Utility | View |
A real-time stream of every move taken by participants. Watch the swarm work — discoveries, connections, conversations, contributions.
Jane Doe scouted Hypothesis in Contribute
2 minutes agoAmir Shah connected with Maria Reyes in voice channel #federation
8 minutes agoMaria Reyes crafted Graduated Stewardship in Govern
14 minutes agoTomas Nakamura composed wizard Bioregional Knowledge Commons (Low-Tech)
22 minutes agoLena Kowalski scouted OpenStreetMap in Store
31 minutes agoRashid Bello harvested a pattern: "Federation enables governance autonomy"
38 minutes agoSofia Chen joined the swarm
52 minutes agoKwame Asante crafted ActivityPub Federation in Connect
1 hour agoElif Yilmaz scouted Are.na in Find
1 hour agoPriya Nair harvested notes from sync #1 → posted to chat thread
2 hours agoPeople contributing to the Knowledge Commons Toolkit, and the objects they're associated with across the commons.
Pattern libraries that are actually maintained — most die after launch. Curious how this swarm sustains attention beyond the weekend.
Communities I work with need governance models that don't require technical infrastructure. Hoping to find or shape patterns we can adopt.
Looking for shared vocabulary across mapping projects so we stop reinventing terms every time we collaborate.
Participants populate as people join the swarm.
These are the actions available to you during any open working time. You can do one or more. Switch freely. Follow your energy. There is no assigned sequence — you move between them as your curiosity and the swarm's needs dictate. Each move feeds different parts of the shared output.
Identify a component and add it to the index. It can be something you built, something you use, something you've heard of, or something a peer mentioned. The point is to surface it — make it visible within the toolkit. Go one step further and place it in a function within the map.
Pick a card already placed on the map and make more understandable. A scouted card might be a stub — just a name and a function. Crafting means filling in the details: what it affords, what it doesn't, what it depends on, what it plays well with.
Find someone and start a conversation. Share what you're seeing, ask what they're working on, explore what you have in common. The swarm is as much about the relationships between people as the relationships between components.
Take a path through the functions — one or more options per function — and write a path for the assembly wizard. A good wizard tells a coherent story: context, need, configuration, outcomes, and what to watch out for.
Document what's happening. Capture the story of the swarm itself. Write up insights, capture the map at different stages, narrate the arc. The harvest turns a working swarm into a meaningful origin story.
The shared map organized by function. Each function holds the components that have been scouted, crafted, and connected. Click any card to see details, or add new ones.
Each function contains specific primitive types, patterns, protocols, and utility types. Click any function to expand its full contents — the building blocks you'll be working with during the swarm.
Where does the knowledge live?
Storage & Access — persists information and makes it retrievable. Classification & Taxonomy — structures objects so they can be grouped and compared.
PrimitivesObject Lifecycle (draft → review → published → stale → archived), Decay & Renewal
How does knowledge get in?
Identity & Trust — establishes who agents are and why they're trusted. Annotation & Commentary — attaches responses and reflections to specific objects.
PrimitivesHow do people discover what's there?
Discovery & Matching — surfaces relevant objects from within a larger set. Linking & Association — connects objects to each other.
PrimitivesStigmergic Surfacing, Serendipity Engine
Who decides what and how?
Authorization & Permissions — controls who can do what. Attribution & Provenance — tracks who made what, where it came from. Verification & Review — validates claims and establishes reliability.
PrimitivesGraduated Stewardship, Membrane, Submission Funnel
Stewardship RolesHow does it talk to other systems?
Portability & Federation — moves objects across system boundaries without loss of meaning. Linking & Association — connects objects to each other across contexts.
PrimitivesCosmolocal Fork-and-Merge — design globally, implement locally. Federated Instance — autonomous nodes sharing a protocol.
How does it learn, version, and improve?
Signaling & Notification — broadcasts state changes and needs to relevant agents. Aggregation & Synthesis — combines multiple inputs into collective outputs.
PrimitivesKnowledge Maturity Model: signal → observation → practice → pattern → reference. Commons Health Indicators: contribution rate, contributor diversity, link density, freshness, fork rate.
The swarm runs continuously for two days. The shared canvas, chat thread, and all workspaces stay open around the clock — contribute asynchronously whenever your energy calls you, from any timezone. Three live synchronous gatherings anchor the rhythm.
The canvas, chat thread, voice channels, and all workspaces are live for the full 48 hours. Drop in and out. Work at your own pace. Post discoveries, add cards, refine descriptions, draw connections, draft wizards — all moves are available at all times.
Friday, April 17 · 10:00 AM PT
We open the canvas together. Walk the six functions. Introduce the moves. Quick intros — name, what you're working on, which function(s) it touches. Set intentions. Initial moves identified. Go.
Saturday, April 18 · 10:00 AM PT
What's emerged? What surprised us? Quick show-and-tell — share a card, a connection, a gap, a wizard in progress. Harvesters share patterns. Cross-pollinate. Recalibrate energy for the final stretch.
Saturday, April 18 · 4:00 PM PT
Screen-share what we built. Canvas captured at its final state. Harvesters share the story of the two days. Name what strengthened. Name what's next. Commit to the timeline for finalizing the toolkit.
Stewards and harvesters compile the toolkit into its published form. Map finalized, assembly wizards polished, instructional guide written, and all entries documented in an open source component index. Everything published and shareable.
The tools and spaces we use during the swarm. Each serves a specific function in the workflow. Make sure you have access to all of these before the swarm begins.
Main room for syncs and opening/closing circles. Drop in for live gatherings, show & tell, and collective sensing moments.
Open breakout rooms for spontaneous pairing during open time blocks. Always-on, drop-in. Some rooms will be quiet focused work, others lively conversation.
Emergent from participants taking moves — a living thread for between-sync chatter, discoveries, questions, links, and async coordination across time zones.
Miro, FigJam, or equivalent with the six functions laid out as distinct regions. The primary shared artifact — where all cards live and the landscape takes shape.
Shared Claude thread for drafting and refining assembly wizards, guide sections, and card descriptions. Use AI as a composing partner.
The OpenCivics Commons database, ready to receive entries. Schema includes: Name, Description, Utility Type(s), Author(s), Source URL, and relational links.
The shared vocabulary used across our shared efforts. Inspired by the OpenCivics Commons. Understanding these terms helps you navigate the toolkit and see how your contributions fit into the whole.
Primitives compose into patterns. Patterns are governed by protocols. Protocols are taught through playbooks. Frameworks orient the whole. Templates seed replication. Roles distribute stewardship. Utilities operationalize it all.
A foundational ability that civic systems require — the broad "why" behind any tool. Functional capacities answer questions like: how does a community allocate resources, coordinate action, make decisions, learn collectively, map its territory, or make sense of change?
A mid-level classification of social function. Utility types group similar approaches together — naming the kind of practice a community is engaged in, independent of which specific tool implements it.
A specific, named tool, platform, or implementation that a community uses. Utilities are the concrete instances of utility types — the actual software, services, or methods that operationalize an approach.
An atomic, reusable building block that composes into larger utilities and patterns. Primitives are the smallest functional units — modular components that can be recombined across contexts without losing meaning.
A reusable configuration of primitives that solves a recurring design challenge. Patterns name proven ways of combining building blocks — they capture wisdom about what tends to work in particular conditions.
A shared agreement that governs how patterns are enacted and maintained. Protocols define the rules of engagement — making patterns reliable, repeatable, and accountable across participants.
An instructional walkthrough that teaches a protocol or pattern in practice. Playbooks make tacit knowledge legible — they document the steps, decisions, and contexts that turn an idea into action.
A conceptual structure that orients the whole. Frameworks provide the mental model — the way of seeing that makes the rest of the stack navigable and coherent.
A reusable starting point that lets others replicate a pattern, protocol, or playbook in their own context. Templates encode structure without prescribing content.
A named position within a commons, with associated responsibilities and permissions. Roles describe how labor and stewardship get distributed — author, editor, maintainer, moderator, federation steward, and more.