Community Ownership

community

Community Ownership

Definition

Community Ownership is a governance and organizational model for software development in which the codebase, documentation, infrastructure, and strategic direction of a project are collectively owned and controlled by its contributor community. Unlike corporate ownership where a legal entity holds exclusive rights, or individual ownership where a single maintainer controls the project, Community Ownership distributes authority, responsibility, and benefit across all participants proportional to their contribution and stake.

Community Ownership is not merely a licensing choice. An MIT-licensed project controlled by a single corporation is not community-owned, even though the code is open. True Community Ownership requires that governance structures, decision-making processes, and resource allocation be transparent, participatory, and resistant to capture by any single entity. It demands that the community -- not any individual or organization -- has ultimate authority over the project's direction.

Overview

The concept of Community Ownership in software draws from Elinor Ostrom's Nobel Prize-winning research on commons governance. Ostrom demonstrated that communities can successfully manage shared resources without either private ownership or government regulation, provided they establish clear rules for access, contribution, monitoring, and conflict resolution. Her eight principles for governing the commons translate directly to software community ownership:

  1. Clearly defined boundaries: Who is a community member with ownership rights
  2. Proportional equivalence: Benefits proportional to contribution
  3. Collective choice arrangements: Community members participate in rule-making
  4. Monitoring: Transparent tracking of contributions and decisions
  5. Graduated sanctions: Proportional consequences for violations
  6. Conflict resolution: Accessible and fair dispute mechanisms
  7. Minimal recognition of rights: External authorities respect community governance
  8. Nested enterprises: Governance scales through layered organization

Ownership Dimensions

Community Ownership operates across multiple dimensions simultaneously:

Legal Ownership: Who holds copyright, trademark, and patent rights. In community-owned projects, these typically vest in a foundation or conservancy that serves as a legal steward on behalf of the community.

Governance Ownership: Who decides project direction, feature priorities, and architectural choices. Community ownership means these decisions follow transparent consensus or voting processes open to qualified contributors.

Operational Ownership: Who manages infrastructure, CI/CD, releases, and day-to-day operations. Community ownership distributes these responsibilities across trusted maintainers with transparent selection processes.

Knowledge Ownership: Who controls documentation, institutional memory, and tacit knowledge. Community ownership ensures knowledge is captured in accessible formats rather than locked in individuals' heads.

Economic Ownership: Who benefits from the project's economic value. Community ownership ensures that value flows back to the community through sustainability mechanisms rather than being extracted by a controlling entity.

Technical Details

Implementing Community Ownership requires infrastructure that tracks ownership stakes, enforces governance rules, and provides transparency into all ownership-related operations.

Ownership Registry

defmodule PrismaticGovernance.OwnershipRegistry do
  @moduledoc """
  Maintains a transparent registry of community ownership stakes.
  Tracks contributions, voting rights, and governance authority
  across all community members.
  """

  use GenServer

  @type ownership_stake :: %{
    contributor_id: String.t(),
    contributions: list(map()),
    voting_weight: float(),
    governance_roles: list(atom()),
    joined_at: DateTime.t(),
    last_active: DateTime.t()
  }

  @governance_roles [:contributor, :reviewer, :maintainer, :core_team, :steward]

  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end

  @impl true
  def init(_opts) do
    state = %{
      registry: %{},
      total_contributions: 0,
      governance_thresholds: %{
        contributor: 1,
        reviewer: 10,
        maintainer: 50,
        core_team: 200,
        steward: 500
      }
    }

    {:ok, state}
  end

  @spec register_contribution(String.t(), map()) :: {:ok, ownership_stake()} | {:error, term()}
  def register_contribution(contributor_id, contribution) do
    GenServer.call(__MODULE__, {:register_contribution, contributor_id, contribution})
  end

  @spec get_ownership_stake(String.t()) :: {:ok, ownership_stake()} | {:error, :not_found}
  def get_ownership_stake(contributor_id) do
    GenServer.call(__MODULE__, {:get_stake, contributor_id})
  end

  @spec get_governance_role(String.t()) :: atom()
  def get_governance_role(contributor_id) do
    GenServer.call(__MODULE__, {:get_role, contributor_id})
  end

  @impl true
  def handle_call({:register_contribution, contributor_id, contribution}, _from, state) do
    stake = Map.get(state.registry, contributor_id, new_stake(contributor_id))

    updated_stake = %{stake |
      contributions: [contribution | stake.contributions],
      last_active: DateTime.utc_now(),
      voting_weight: calculate_voting_weight(stake.contributions, contribution),
      governance_roles: determine_roles(length(stake.contributions) + 1, state.governance_thresholds)
    }

    new_registry = Map.put(state.registry, contributor_id, updated_stake)
    new_state = %{state | registry: new_registry, total_contributions: state.total_contributions + 1}

    {:reply, {:ok, updated_stake}, new_state}
  end

  @impl true
  def handle_call({:get_stake, contributor_id}, _from, state) do
    case Map.get(state.registry, contributor_id) do
      nil -> {:reply, {:error, :not_found}, state}
      stake -> {:reply, {:ok, stake}, state}
    end
  end

  @impl true
  def handle_call({:get_role, contributor_id}, _from, state) do
    role =
      case Map.get(state.registry, contributor_id) do
        nil -> :none
        stake -> highest_role(stake.governance_roles)
      end

    {:reply, role, state}
  end

  defp new_stake(contributor_id) do
    %{
      contributor_id: contributor_id,
      contributions: [],
      voting_weight: 0.0,
      governance_roles: [],
      joined_at: DateTime.utc_now(),
      last_active: DateTime.utc_now()
    }
  end

  defp calculate_voting_weight(existing, _new_contribution) do
    base = length(existing) + 1
    recency_factor = 1.0
    :math.log2(base + 1) * recency_factor
  end

  defp determine_roles(contribution_count, thresholds) do
    @governance_roles
    |> Enum.filter(fn role ->
      Map.get(thresholds, role, :infinity) <= contribution_count
    end)
  end

  defp highest_role([]), do: :none
  defp highest_role(roles) do
    role_order = Enum.with_index(@governance_roles)
    roles
    |> Enum.max_by(fn role ->
      Enum.find_value(role_order, 0, fn {r, i} -> if r == role, do: i end)
    end)
  end
end

Governance Voting System

Community Ownership requires transparent voting mechanisms for collective decision-making:

defmodule PrismaticGovernance.VotingSystem do
  @moduledoc """
  Implements weighted voting for community governance decisions.
  Voting weight is determined by contribution history and
  governance role within the community ownership structure.
  """

  alias PrismaticGovernance.OwnershipRegistry

  @type vote :: :for | :against | :abstain
  @type vote_record :: %{voter_id: String.t(), vote: vote(), weight: float(), timestamp: DateTime.t()}

  @spec cast_vote(String.t(), String.t(), vote()) :: {:ok, vote_record()} | {:error, term()}
  def cast_vote(proposal_id, voter_id, vote) when vote in [:for, :against, :abstain] do
    with {:ok, stake} <- OwnershipRegistry.get_ownership_stake(voter_id),
         :ok <- validate_voting_eligibility(stake),
         :ok <- validate_no_duplicate_vote(proposal_id, voter_id) do
      record = %{
        proposal_id: proposal_id,
        voter_id: voter_id,
        vote: vote,
        weight: stake.voting_weight,
        governance_role: highest_role(stake.governance_roles),
        timestamp: DateTime.utc_now()
      }

      with {:ok, stored} <- PrismaticStorage.insert(record),
           :ok <- update_vote_tally(proposal_id) do
        {:ok, stored}
      end
    end
  end

  @spec tally_votes(String.t()) :: {:ok, map()} | {:error, term()}
  def tally_votes(proposal_id) do
    with {:ok, votes} <- PrismaticStorage.get_all_votes(proposal_id) do
      tally = %{
        total_voters: length(votes),
        weighted_for: sum_weighted_votes(votes, :for),
        weighted_against: sum_weighted_votes(votes, :against),
        weighted_abstain: sum_weighted_votes(votes, :abstain),
        unweighted_for: count_votes(votes, :for),
        unweighted_against: count_votes(votes, :against),
        unweighted_abstain: count_votes(votes, :abstain),
        quorum_met: length(votes) >= quorum_threshold(),
        result: determine_result(votes)
      }

      {:ok, tally}
    end
  end

  defp validate_voting_eligibility(stake) do
    if :contributor in stake.governance_roles do
      :ok
    else
      {:error, "Minimum contributor status required for voting"}
    end
  end

  defp validate_no_duplicate_vote(proposal_id, voter_id) do
    case PrismaticStorage.find_vote(proposal_id, voter_id) do
      {:ok, _} -> {:error, "Already voted on this proposal"}
      {:error, :not_found} -> :ok
    end
  end

  defp sum_weighted_votes(votes, type) do
    votes
    |> Enum.filter(&(&1.vote == type))
    |> Enum.reduce(0.0, &(&1.weight + &2))
  end

  defp count_votes(votes, type) do
    Enum.count(votes, &(&1.vote == type))
  end

  defp quorum_threshold, do: 5

  defp determine_result(votes) do
    for_weight = sum_weighted_votes(votes, :for)
    against_weight = sum_weighted_votes(votes, :against)

    cond do
      length(votes) < quorum_threshold() -> :no_quorum
      for_weight > against_weight * 1.5 -> :approved
      against_weight > for_weight * 1.5 -> :rejected
      true -> :undecided
    end
  end

  defp highest_role([]), do: :none
  defp highest_role(roles), do: List.last(roles)

  defp update_vote_tally(_proposal_id), do: :ok
end

Ownership Transfer Protocol

When contributors leave or new governance structures are needed, ownership must be transferable:

defmodule PrismaticGovernance.OwnershipTransfer do
  @moduledoc """
  Manages the transfer of ownership stakes and governance authority
  within the community. Ensures continuity and prevents ownership
  concentration.
  """

  @spec transfer_maintainership(String.t(), String.t(), String.t()) ::
    {:ok, map()} | {:error, term()}
  def transfer_maintainership(component, from_id, to_id) do
    with {:ok, from_stake} <- PrismaticGovernance.OwnershipRegistry.get_ownership_stake(from_id),
         {:ok, to_stake} <- PrismaticGovernance.OwnershipRegistry.get_ownership_stake(to_id),
         :ok <- validate_transfer_eligibility(from_stake, to_stake, component),
         :ok <- require_community_approval(component, from_id, to_id) do
      record_transfer(component, from_id, to_id)
    end
  end

  defp validate_transfer_eligibility(from_stake, to_stake, _component) do
    cond do
      :maintainer not in from_stake.governance_roles ->
        {:error, "Transferor must be current maintainer"}

      :reviewer not in to_stake.governance_roles ->
        {:error, "Recipient must have at least reviewer status"}

      true ->
        :ok
    end
  end

  defp require_community_approval(component, from_id, to_id) do
    proposal = %{
      title: "Transfer maintainership of #{component}",
      description: "Transfer from #{from_id} to #{to_id}",
      category: :governance,
      requires_supermajority: true
    }

    PrismaticGovernance.Proposal.create_changeset(
      Map.put(proposal, :author_id, from_id)
    )

    :ok
  end

  defp record_transfer(component, from_id, to_id) do
    transfer = %{
      component: component,
      from: from_id,
      to: to_id,
      timestamp: DateTime.utc_now(),
      type: :maintainership_transfer
    }

    PrismaticStorage.append_only_insert(transfer)
  end
end

Implementation in Prismatic Platform

Umbrella Application Ownership

Each of the 115 umbrella applications in the Prismatic Platform has identifiable ownership through its CLAUDE.md documentation, quality DNA state, and contribution history. Applications are grouped by domain (storage, web, agents, intelligence), with domain-level ownership vesting in contributors who have demonstrated sustained commitment to that domain.

AIAD Specification Ownership

The 530+ AIAD agents and 225 commands are community-owned specifications. Any contributor can propose new agents, modify existing specifications, or challenge architectural decisions. The AIAD standard itself is community-governed, with changes requiring transparent review.

Quality System Stewardship

The quality measurement system (13 domains, 100/100 score) is collectively owned. No single contributor or team can unilaterally relax quality gates, skip Credo rules, or modify Dialyzer expectations. Quality changes follow the same governance process as feature changes.

Session Context as Shared Knowledge

Session contexts (saved in .claude/session-context/) represent shared operational knowledge. While individual sessions are authored by specific contributors, the accumulated session context forms a community-owned knowledge base that informs future development.

Open-Source Package Governance

The four published OSS packages (SDK, Plugin Kit, Security, UI) each have their own governance structure within the community ownership framework. Package maintainers are selected through community consensus, and package roadmaps follow community prioritization.

Comparison with Alternatives

Corporate Ownership

In corporate ownership, a company holds legal rights (copyright, trademark, patents) and exercises control over all aspects of the project. Employees contribute as part of their employment; their contributions are work-for-hire. The company can change direction, licensing, pricing, or even discontinue the project unilaterally.

Individual Maintainer Ownership

Many open-source projects are effectively owned by their original creator. While they may accept contributions, final authority rests with one person. This creates bus-factor risk and succession challenges.

Foundation Ownership

Software foundations (Apache, Linux, Eclipse) provide legal and governance infrastructure for community ownership. They hold IP in trust for the community. This model is mature and well-tested but requires significant organizational overhead.

Cooperative Ownership

Software cooperatives (like some worker-owned development shops) combine community ownership with formal legal cooperative structure. Members have equal voting rights regardless of contribution volume.

ModelDecision AuthorityLegal StructureRisk Factor
CorporateExecutivesCorporationCorporate capture
IndividualCreatorPersonalBus factor
FoundationBoard (elected)Non-profitBureaucracy
CooperativeMembers (equal)CooperativeSlow decisions
Community (Prismatic)Contributors (weighted)Open license + governanceCoordination cost

Best Practices

  1. Formalize ownership structures early. Implicit ownership creates ambiguity that leads to conflict. Document who owns what, how ownership is acquired, and how it can be transferred.

  2. Separate legal and governance ownership. Legal ownership (copyright assignment, trademark) should vest in a neutral entity (foundation, conservancy). Governance ownership (decision-making authority) should distribute across active contributors.

  3. Implement graduated ownership. New contributors should gain ownership stakes progressively as they demonstrate commitment. The Prismatic model uses contribution-count thresholds for advancing from contributor to reviewer to maintainer to core team.

  4. Make ownership visible. Every file, module, and component should have visible ownership metadata. The Prismatic Platform achieves this through CLAUDE.md files, quality DNA states, and git history analysis.

  5. Prevent ownership concentration. No single contributor, company, or bloc should be able to acquire controlling ownership. Implement caps on voting weight and require diverse approval for governance changes.

  6. Plan for succession. Document ownership transfer procedures before they are needed. Maintainer burnout and departure are predictable events that should not create governance crises.

  7. Align incentives with ownership. Contributors who invest more should have proportionally more influence, but not unlimited control. The weighted voting system balances meritocratic recognition with democratic safeguards.

  8. Audit ownership regularly. Review ownership distribution periodically to identify concentration risks, inactive owners, and governance gaps.

Common Pitfalls

  1. Paper ownership without real authority. Declaring community ownership while maintaining informal corporate control through employment relationships, information asymmetry, or infrastructure control.

  2. Inactive owner accumulation. Contributors who earned ownership stakes years ago but are no longer active retaining governance influence. Implement activity-based decay or emeritus status.

  3. Ownership without responsibility. Ownership confers not just rights but obligations: maintenance, review, mentoring, and governance participation. Communities that grant ownership without expectations create governance debt.

  4. Fragmented ownership. When ownership becomes too distributed, coordination costs can exceed the benefits. Maintain clear hierarchical ownership (component -> domain -> platform) to manage complexity.

  5. Ownership as gatekeeping. Using ownership structures to exclude newcomers rather than to empower them. Ownership thresholds should be achievable and transparent, not designed to preserve incumbent power.

  6. Ignoring legal frameworks. Community ownership sentiments without proper legal structure (contributor license agreements, trademark policies, foundation incorporation) leave the community vulnerable to legal challenges.

  7. Conflating contribution with ownership. A single large code dump does not constitute ownership. Sustained engagement, community participation, and governance involvement are equally important dimensions of ownership.

Use Cases

Large-Scale Open-Source Platforms

Platforms like Prismatic with 115 apps and 2.8M lines of code require structured community ownership to maintain coherence across the codebase. Without it, different parts of the platform would evolve incompatibly.

Security-Sensitive Projects

Security tools benefit from community ownership because distributed trust is more resilient than centralized trust. No single entity can insert vulnerabilities when ownership is genuinely distributed.

Cross-Organizational Collaboration

When multiple organizations collaborate on shared infrastructure, community ownership provides a neutral governance framework that prevents any single organization from dominating.

Long-Lived Projects

Projects expected to outlive their original creators need community ownership to ensure continuity. Individual and corporate ownership both create succession risks that community ownership mitigates.

Compliance-Critical Systems

Regulatory compliance frameworks implemented through community-owned projects benefit from diverse audit perspectives and resistance to corporate pressure to weaken compliance.

Community Ownership intersects with many foundational concepts in the Prismatic Platform ecosystem:

  • Community Over Corporation -- The philosophical principle that community governance should take precedence over corporate control in software development.
  • Community-Owned Innovation -- How community ownership enables innovation that serves collective needs rather than corporate profit.
  • Complete Transparency -- The operational visibility required for meaningful community ownership, since owners cannot govern what they cannot see.
  • Collaborative Development -- The technical workflows that enable multiple community owners to contribute effectively.
  • Share Openly -- The practice of making all project outputs available to the community, which is foundational to genuine ownership.
  • Developer Community -- The human community in which ownership is vested and through which governance operates.
  • Audit Trail -- Immutable records of governance decisions that ensure ownership transparency and accountability.
  • Community Building -- Growing the pool of potential owners through outreach, mentoring, and contributor onboarding.
  • Sustainable Funding Models -- Financial mechanisms that sustain community-owned projects without introducing ownership distortion.
  • Quality and Transparency -- How community ownership of quality systems ensures standards serve the community rather than corporate metrics.

See Also

Community Ownership is a structural pillar of the Prismatic Platform's governance model. To understand your ownership stake and governance rights, visit the Developer Portal.

Connect & Contribute: Built by Tomas Korcak (korczis) and the Prismatic community. Open source under GHL license. GitHub | GitLab | LinkedIn | Contact

Back to Glossary