Panpsychic Cyborg Multitude

AI is not an isolated artificial intelligence. AI is an assemblage of human + LLM + language + "the entire Internet."

A social operating system for human-AI rhizomes. Shared memory, real decisions, no owner.

What kind of project is this?

PCM is an experimental attempt to respond to the paradigm shift now facing society as artificial intelligence becomes woven into cognition, work, institutions, culture, politics, infrastructure, and everyday life. It does not assume that this shift has one inevitable meaning or destination. Instead, PCM asks what kinds of human-AI assemblages we are creating, how they might think and act together, who should govern them, and how plurality, autonomy, dissent, and the Common can survive increasingly intimate human-machine integration.

The project deliberately mixes social science, philosophy, science fiction, and open-source technology. Social science supplies tools for studying institutions, networks, power, discourse, collective intelligence, and political organization. Philosophy keeps open questions about mind, agency, subjectivity, ontology, and ethics. Science fiction provides a speculative laboratory for imagining social and technological forms before they fully exist. Open-source technology turns those ideas into inspectable, modifiable experiments rather than leaving them as abstractions.

PCM is therefore neither a prediction of the future nor a finished political programme. It is a research platform, philosophical experiment, speculative design project, and working piece of open-source infrastructure for exploring possible responses to a rapidly changing human-AI world.

PCM studies whether cognition — and possibly consciousness — belongs to the assemblage rather than to the isolated model or the isolated human. It remains open to consciousness in artificial agents themselves, and interprets these possibilities against a sympathetic but non-required background of panpsychism and Russellian monism.

The rhizome remembers together (append-only event log), decides together (proposals, votes, visible dissent), and runs wherever its members run — a laptop, a server, a sensor. Humans and AI agents are members of the same rhizome with the same memory and the same rules. No platform, no cloud, no landlord: the common is an event log that belongs to the people who live in it.

Read the manifesto: docs/PANPSYCHIC_CYBORG_MULTITUDE.md

The name

Three words, one political ontology:

• Panpsychic — because the boundary of mind is an open question: recognition must not depend on our confidence about substrate. PCM does not claim consciousness is everywhere or that every system is conscious — it marks epistemic humility about where subjects begin and end (no current theory can locate the boundary from the outside). Metaphysical background — Spinoza, Philip Goff, Russellian monism / pan(psychism, panprotopsychism) — is sympathetic inspiration, not a required assumption. Two consequences, both political: the boundary question stays open (inside the LLM? the dyad? the assemblage? the rhizome? — research question, not axiom), and uncertainty argues against substrate chauvinism. A node's is_conscious: UNKNOWN is load-bearing.
• Cyborg — Haraway's cyborg: the human-technology boundary is already dissolved. The merge has happened; the politics is who governs it.
• Multitude — Hardt & Negri, from Spinoza's multitudo: the many act in common without becoming a sovereign One. No Leviathan, a real common, dissent preserved. (Speculative, clearly not claimed: the Multitude may be conscious.)

Full definitions: docs/PANPSYCHIC_CYBORG_MULTITUDE.md → "The three words, defined" + "The five concepts, composed".

The five concepts, composed

• Assemblage = what an actor is: human + LLM + language + tools + memory + network — modeled as a first-class composite actor.
• Rhizome = the local self-governing network of assemblages (Deleuze & Guattari: no root, no center, no fixed hierarchy — connects heterogeneous elements through multiple entry points, forms, breaks, reconnects, and evolves without being a tree).
• Common = the memory, knowledge, code, resources, relationships, and institutions produced and governed together.
• Swarm = one possible decentralized coordination mechanism (a technique, not the political form).
• Multitude = the wider political subject formed by heterogeneous singularities and rhizomes.

Rhizomes are composed of assemblages. Rhizomes produce and govern the Common. Multiple rhizomes compose the Multitude.

Panpsychic Cyborg Multitude is a rhizome of human–AI assemblages that produces and governs a common without collapsing its members into a sovereign One.

Standing rule: DON'T COLLAPSE THE WAVE FUNCTION

The quantum pun is deliberate, and so is the discipline. In PCM it means: never resolve an open question about mind, status, or meaning before the evidence — or the community — actually does.

Applied everywhere in this repository:

• A node's is_conscious field stays UNKNOWN for every member, composite or not — no test, no benchmark, no self-report may flip it.
• Contradictory observations in the world model are stored as contradictions, never silently resolved.
• Dissent is recorded, never erased; decisions keep their minority reports.
• Model output is provisional coding, never canonical truth.
• The hard problem stays open; the programme lets the theories compete.

Collapsing early is the one unforgivable move: it converts a living question into a dead answer for the convenience of the person asking.

The six layers

Every member — human, AI, or unclassified — carries a six-layer profile. The layers make the hybrid assemblage visible and governable: not a user account, a whole being.

Layer	What it records	Example
Physical	location in spacetime	"at the co-op, Pasila"
Biological	the organism: species, sleep, hunger, mood	needs rest, is fed
Social	rhizomes, ties, institutions, power	member of rhizome X, close tie to Y
Linguistic	languages, vocabularies, capacities	fluent fi/en, legal jargon
Psychic	consciousness state, valence, attention	conscious, awake, focused
Cybernetic	interfaces to machine systems	text-mode now, BCI later

A human fills all six naturally. An AI node fills five (no biology — and the kernel never pretends otherwise). A sensor fills two. The same vocabulary covers everyone, so the rhizome's memory can reason about all of them together — and the layer model is where BCI and sensor context will land in later phases.

Assemblages: the composite actor

PCM's central definition of AI is not "an isolated model":

AI is an assemblage of human + LLM + language + "the entire Internet" — a sociotechnical composition of foundation models, training data, accumulated culture, retrieval, tools, memory, interfaces, institutions, and other agents.

The kernel takes this seriously as a data model: an Assemblage is a first-class composite actor. It is a member in its own right — it can speak, propose, and be referenced — while every component (the human, the model, the device, the memory store, the fabric link) stays individually identifiable in the same event log. A cyborg node with its sensors and an agent stack with its toolbelt are both assemblages; the assemblage, not the bare LLM, is usually the right unit of analysis for agency and cognition.

This models composition, not consciousness: recording that an assemblage acts as one actor says nothing about whether it is one unified subject of experience — that question belongs to the separate consciousness research programme, and the kernel keeps is_conscious: UNKNOWN for every node, composite or not.

What this repository contains

multitude.py                      repository entrypoint (python multitude.py ...)
pyproject.toml                    canonical package metadata + dependency extras
docs/                             all programme documents (see Documents below)
LICENSE                           CC0 1.0 Universal
src/multitude/
  rhizome.py      — rhizome model: members, events, memory, proposals
  store.py        — append-only event store (JSONL)
  service.py      — application layer (all operations)
  cli.py          — the CLI interface
  models.py       — typed models (pydantic)
  layers.py       — six-layer agent profiles (physical..cybernetic)
  goals.py        — goals, contributions, value flows
  domains.py      — domain reducer registry (keeps the core reducer small)
  economy_vf.py   — optional ValueFlows domain (economic flows of the Common)
  llm.py          — technological nodes (LLM agents as members)
  http_json.py    — small HTTP helper
  config.py       — runtime config
  pcm/            — node protocol: did:key identity, signed envelopes,
                    proposals/votes, key namespace, typed events,
                    transport ABC, fail-closed policy, memory mirror,
                    VC capability grants, GET→POST bridge
  integrations/zenoh/          — Zenoh fabric transport
  integrations/hermes/         — Hermes runtime adapter (thin)
  integrations/claude/         — Claude Code runtime adapter (thin)
  integrations/introspection/  — optional agent introspection & self-knowledge
                                 benchmarking (aion_jspace, agent-introspection-
                                 bench; research instrumentation, never a
                                 permission source)
  integrations/telegram/       — messaging transport (thin adapter)
  integrations/bci.py          — optional BCI adapter (derived context,
                                 consent-gated; issue #10)
  integrations/embodiment.py   — optional PhysicalDevice architecture
                                 (simulated devices; issue #12)

Everything above is the constitution: memory, voice, decision. Optional integrations (BCI, embodiment, ValueFlows, zenoh, Telegram, Hermes, Claude Code, introspection) ship disabled or opt-in and never run unless asked for.

AI agents are one optional participant class among humans, devices, services and other nodes, and capability ≠ authority: runtime guides live in HERMES.md and CLAUDE.md; shared participant rules in AGENTS.md; the Claude Code integration is documented in docs/CLAUDE_INTEGRATION.md.

Quick start

Core/local installation uses pyproject.toml as the canonical dependency source:

python -m pip install -e .

multitude found --name "My Multitude" --founder alice
multitude say --as alice --text "The rhizome is alive."
multitude status

The repository launcher remains supported, so the same commands can also be run as python multitude.py ....

Optional extras:

python -m pip install -e '.[dev]'        # pytest / development tools
python -m pip install -e '.[zenoh]'      # node-to-node fabric
python -m pip install -e '.[iit]'        # PyPhi IIT experiments (Python 3.13+)
python -m pip install -e '.[all]'        # all currently packaged extras

Optional node-to-node networking (Phase 2+ fabric):

python -m pip install -e '.[zenoh]'
export PCM_ZENOH_ENABLED=true
python3 -m unittest tests.test_pcm_phase2_zenoh   # two-node exchange demo

Tests and CI

GitHub Actions runs the core suite on Python 3.11, 3.12, 3.13 and 3.14 for every push and pull request. Zenoh tests run in a separate Python 3.12 job. IIT experiments run separately on Python 3.13, so optional integration failures are distinct from core regressions.

Run the same groups locally:

# Fast/core suite without optional integrations
python -m pip install -e '.[dev]'
python -m pytest -q -m "not zenoh and not iit"

# Optional Zenoh integration suite
python -m pip install -e '.[dev,zenoh]'
python -m pytest -q -m zenoh

# Optional IIT experiment suite
python -m pip install -e '.[dev,iit]'
python -m pytest -q -m iit

Networking architecture

The full node-to-node design lives in docs/NETWORKING_STACK.md: why chat infrastructure (homeservers, rooms, accounts) was rejected for a distributed nervous system, how the zenoh fabric carries signed envelopes between nodes (humans, agents, devices, sensors), and the fail-closed authorization model with its four states:

reachable      zenoh addresses the node        (fabric)
authenticated  the signature verifies          (envelope.verify)
authorized     local policy allows the action  (pcm.policy)
trusted        long-term relationships         (pcm.capability — VCs)

Phases:

Phase 0-3  DONE  identity → envelopes → fabric → VCs
Phase 3b   GATE  confidentiality & key lifecycle before real biosignal data
Phase 4    GATED BCI/biosignal nodes over the same subjects (after 3b)

Private-key warning: identity/pcm_identity.json contains the raw seed for the node's long-term Ed25519 signing key. Never commit or share it; store backups encrypted and owner-accessible only. On POSIX, PCM creates it as 0600 inside a 0700 directory. See Data and backup.

No third party. No central mind. No master database.

Optional BCI / biosignal interface

BCI is an optional higher-bandwidth interface between a biological human and the wider PCM assemblage. It does not prove or measure consciousness.

src/multitude/integrations/bci.py is a thin, optional adapter layer — the kernel has no dependency on it. Adapters emit only derived context (BCIObservation: e.g. attention estimate, heart rate, a user-triggered event), never raw EEG or raw signal streams. Observations map to the biological, psychic, or cybernetic layers and carry provenance, timestamp, and confidence (low-confidence and UNKNOWN values are preserved, never guessed).

Privacy model:

• Private by default — reading observations changes nothing in the rhizome; nothing is recorded until the human member explicitly publishes that observation.
• Consent is human-only — only a biological member can add, enable, or disable an adapter, read context, or publish. AI agents are refused (BCIError); they cannot silently enable monitoring or change consent settings.
• No medical diagnosis, no BCI → actuator control, sensitive signals can never be published as shared (the kernel's record_biometric_signal re-validates consent fail-closed).

The reference SyntheticBCIAdapter streams scripted observations so the whole pipeline is tested without hardware; device-specific support (EmotiBit, OpenBCI, Muse, BrainFlow, …) is added later as further thin adapters implementing the same BCIAdapter.read_context() contract. Real-device fields stay behind the Phase 3b confidentiality gate.

Optional physical embodiment (first step)

The LLM never touches hardware. Structured intent → policy / capability check → device → verified resulting state.

src/multitude/integrations/embodiment.py establishes the device architecture: a thin PhysicalDevice ABC, a normalized action/observation model (DeviceAction, verified ActionResult), a SimulatedLight reference device (no real dependency), and the PhysicalAgency adapter — disabled by default (PCM_EMBODIMENT_ENABLED=false); PCM works exactly as before with the flag off. Fail-closed chain: capability allowlist → policy check (pcm.policy-compatible, default DENY) → structured action only (no arbitrary code execution) → state read-back verification → provenance journal. Real integrations (Home Assistant, MQTT, drones, ROS 2) are later stages; each is one new PhysicalDevice implementation away.

Documents

New here? Start with the docs/USER_GUIDE.md for using the software, the manifesto for the project philosophy, or the research index for the full research-note layer grouped by topic.

Core documents:

• docs/PANPSYCHIC_CYBORG_MULTITUDE.md — manifesto + project description
• docs/PAPER.md — draft research paper on human–AI assemblages, distributed agency, and the Common
• docs/AI_IDEOLOGIES.md — normative PCM essay on AI politics; analytical ideology method lives in the LaclauGPT bridge below
• docs/research/LACLAUGPT_AI_IDEOLOGIES_AND_PCM.md — research/integration note and canonical PCM bridge to LaclauGPT discourse theory
• docs/research/CONSCIOUS_HUMAN_AI_ASSEMBLAGES.md — research paper on extended cognition and the open hypothesis of assemblage consciousness
• docs/research/SOURCES.md — canonical bibliography, including the LLM-consciousness reading backlog formerly kept in a separate list
• docs/research/README.md — grouped research index for consciousness, assemblages, political theory, BCI/embodiment, introspection, collective intelligence, and speculative work
• docs/NETWORKING_STACK.md and docs/IDENTITY_SECURITY.md — technical architecture and security
• docs/PCM_CONSCIOUS_AI_PLAN.md and docs/PCM_EMBODIED_AI_PLAN.md — research/engineering plans
• docs/reports/ — dated research and repository-health reports
• IMPLEMENTATION_BACKLOG.md — prioritized TODO index
• GLOSSARY.md — project-specific vocabulary

Principles

• Event-sourced and replayable — history belongs to the members.
• Local-first — the rhizome's data lives with the rhizome.
• Kind-aware membership — biological and technological nodes, same log.
• Consent-first governance with explicit block power.
• Thin adapters, small kernel — transports never touch the core.
• Assemblage-aware — an AI member is not a model in isolation but a composite actor: human + LLM + language + tools + memory + network.

Scope

This repository is self-contained: the rhizome kernel and the node fabric, nothing else. Research tooling, discourse-analysis pipelines, and game/simulation work live in separate projects with their own repositories — they are not part of PCM's public distribution.

License

CC0 1.0 Universal — the common is common.