RHIZOME
A coordination practice for making authority, responsibility, tension, and organizational memory visible — and an emerging software system for keeping that context shared over time.
Fifteen years inside alternative organizations kept revealing the same coordination problems.
Across art collectives, communities, cooperatives, DAOs, and other experiments in shared ownership, I kept encountering a familiar gap: authority could be distributed on paper while context, judgment, and memory remained concentrated in a few people.
The result was recurring decision fog, invisible coordination work, founder gravity, responsibility without authority, and tensions that returned because the underlying structure never became explicit.
Shared creation
Strong autonomy, weak clarity around ownership and informal power.
Participation
Belonging did not answer who could decide, hold boundaries, or carry consequence.
Shared ownership
Formal equality did not automatically distribute context, resources, or judgment.
Distributed coordination
Technical decentralization could still leave social authority concentrated.
Start with what is happening, then make the structure visible.
The method follows the work from a lived tension to a durable organizational change.
Surface tension
Understand context
Map authority
Decide
Assign ownership
Preserve what changed
How we work
The practice for sensing, clarifying, deciding, and learning.
How we intervene
Structured tools for diagnosis, authority, decisions, and tension.
How we read the field
A shared view of patterns, tensions, and next moves.
How memory persists
A relational substrate for the context produced through the work.
Four instruments turn vague organizational friction into something a group can act on.
Find the pattern
Looks across authority, responsibility, decision flow, information, tension, resources, belonging, and trust to understand why the group keeps getting stuck.
Compare stated and lived authority
Maps formal authority, actual authority, responsibility, load, resource control, dependencies, and tensions.
Make the decision complete
Brings context, authority, options, commitments, ownership, and review into one explicit decision record.
Turn friction into response
Separates event from interpretation, locates the system condition underneath it, and routes the tension toward repair, clarification, decision, or experiment.
A recurring approval bottleneck becomes a change in authority.
Consider a team where a Product Lead formally owns client pricing, but meaningful pricing decisions still route through the founder.
Tension appears
Diagnostic finds bottleneck
Authority mismatch mapped
Tension explored
Decision composed
Ownership changes
Memory updates
Authority is nominally distributed
Product owns the domain on paper, while approvals and reassurance still flow upward.
Decision rights become explicit
Product can decide within a defined scope, Finance has a bounded stop condition, and the founder is informed rather than asked for approval.
A living reading of what is happening in the collective now.
Core gathers the current patterns, the field map, the tension that needs attention, and the next experiments in one shared document. It is not a reporting dashboard; it is a working interpretation of the organization.
Decision fog
Important decisions remain ambiguous because authority and context are unclear.
Invisible holding
Care and coordination work are concentrated without matching authority or recognition.
Decision bottleneck slows momentum
Too many consequential choices still route through a small number of people.
Clearer local authority
Move defined decisions closer to the people carrying the work.
Clarify decision rights
Remove one approval step
Review after 30 days
The map is the interface.
Node keeps the situations behind the collective reading connected over time. A decision is not an isolated record: it sits inside a field of people, observations, tensions, patterns, needs, and experiments.
Client decision
AI can help navigate the memory without becoming the source of truth.
The software direction separates interpretation from durable state. A language model can understand a request and choose a capability, while typed Rust functions operate on structured organizational data.
Question / action
Ask what changed, who owns a decision, or record a commitment.
AI layer
Understands intent and chooses an explicit capability.
Rust tools
Read, write, link, validate, and query structured objects.
Rhizome Node
Relationships, history, organizational state.
Visible evidence
Answer, map, proposed change, or confirmed action.
The method is ahead of the software.
The instruments, system model, and product direction are already concrete. Rhizome Node is still early-stage software. The current engineering work is focused on typed organizational objects, CLI behavior, validation, and the path toward persistent relationships and query.
Method + instruments
Diagnostic, Authority Canvas, Decision Composer, Tension Protocol, system maps, and workshop material.
Node foundation
Rust repository, typed domain structures, commands, validation, and tests.
Field testing
Use the method with real teams, preserve the resulting context, and test whether shared memory changes coordination.
Distributing decisions is not enough if context stays concentrated.
Authority has to be inspectable
Titles and governance documents matter less than where decisions, resources, and consequences actually move.
Memory is coordination infrastructure
A group cannot distribute judgment if the history needed for judgment remains trapped in a few people.
Mismatch is useful data
The gap between stated structure and lived behavior is not noise; it is often the most important design signal.