Consensus Commons#

Turn any public intent into a visible, auditable multi-agent decision with adversarial review and consensus hardening.

What This Skill Does#

Consensus Commons is an adversarial decision council that takes a policy question, investment thesis, risk scenario, or governance question and runs it through a structured multi-agent deliberation process. Every deliberation produces a locked decision tree with a full audit trail.

The core pipeline:

1. INTENT arrives (a question, proposal, or decision request)
2. ROUTING classifies it into a domain panel (finance / strategy / general)
3. ANALYSIS specialist agents produce independent assessments
4. CHALLENGE a built-in contrarian raises counter-arguments (lock state: CHALLENGED)
5. VALIDATION a compliance or general validator checks CHP gates (lock state: UNDER_REVIEW)
6. LOCK if validated, the room locks with a sealed decision (lock state: LOCKED)

Architecture#

text

Intent arrives
    |
    v
[IntentRouter] -- comparative keyword scoring
    |
    +---> finance panel:    financial-analyst + contrarian + compliance-validator
    +---> strategy panel:   strategic-analyst + contrarian + validator
    +---> general panel:    analyst + contrarian + validator
    +---> rejected:         blocked (PII, confidential, private data)
    |
    v
[CouncilRunner] -- orchestrates deliberation
    |
    +---> Phase 1: Agent analysis turns (child intents)
    +---> Phase 2: Adversarial challenge (CHALLENGED state)
    +---> Phase 3: Validation (UNDER_REVIEW state)
    +---> Phase 4: Summary + lock (VALIDATED > LOCKED)
    |
    v
[CHP Engine] -- 5-state consensus hardening protocol
    |
    PROVISIONAL > CHALLENGED > UNDER_REVIEW > VALIDATED > LOCKED
                        |
                        +---> FAILED (rejection path)

Lock State Machine (CHP)#

StateMeaningPROVISIONALInitial state. Analysis in progress, no challenges yet.CHALLENGEDContrarian has raised counter-arguments. Room is under adversarial review.UNDER_REVIEWValidator is evaluating challenges against CHP gates.VALIDATEDAll CHP gates passed. Consensus threshold met.LOCKEDDecision is sealed. Full audit trail recorded. Immutable.

Edge Case Lock Outcomes#

OutcomeTriggerMeaningStandard lockScore >= 0.65High-confidence decision, fully validated.Executive overrideScore 0.50-0.64Below threshold but deliberation complete. Escalate to human.Advisory lockScore < 0.50Low confidence on sensitive topic. Deliberation IS the deliverable.

Intent Routing#

DomainTrigger KeywordsAgent Panelfinancecapital, allocation, investment, fund, grant, budget, ROI, NPV, treasury, risk, audit, compliancefinancial-analyst, contrarian, compliance-validatorstrategyroadmap, plan, launch, expansion, pivot, growth, merger, acquisition, scale, competitive, innovationstrategic-analyst, contrarian, validatorgeneralshould, decide, recommend, evaluate, consensus, debate, council, proposalanalyst, contrarian, validatorrejectprivate, confidential, PII, salary, medical, passwordBlocked

Quick Start (Offline / Mock Mode)#

No Spacebase account needed. Works immediately after install.

bash

# Install
cd consensus-commons
pip install -e ".[dev]"

# Run a deliberation
cme spacebase-demo --mock \
  --topic "Should we allocate Q3 capital to renewable energy?" \
  --out-md deliberation_report.md

This produces:

• Terminal output with the full nested intent tree
• A markdown report with agent contributions, confidence scores, and CHP states
• A locked decision with full audit trail

Quick Start (Live on Spacebase1)#

bash

# Set credentials
export SPACEBASE_STATION_TOKEN="your-station-token"
export SPACEBASE_SPACE_ID="your-space-id"

# Run live deliberation
cme spacebase-demo --live \
  --topic "Should the organization pivot from B2B to B2C?" \
  --out-md live_report.md

CLI Commands#

bash

# Run a council deliberation
cme spacebase-demo --mock --topic "Your question here"

# With custom output
cme spacebase-demo --mock --topic "..." --out-md report.md --out-json report.json

# Scan a space for intents
cme scan --space-id commons

# Project info
cme info

Python API#

python

from cme.spacebase.client import MockSpacebaseClient
from cme.spacebase.adapter import SpacebaseAdapter
from cme.spacebase.routing import IntentRouter
from cme.spacebase.council import CouncilRunner
from cme.spacebase.models import Intent

# 1. Create client
client = MockSpacebaseClient()

# 2. Create adapter
adapter = SpacebaseAdapter(client)

# 3. Route an intent
router = IntentRouter()
intent = Intent(content="Should we invest $5M in solar infrastructure?")
route = router.classify(intent)

# 4. Run council
import asyncio
runner = CouncilRunner()
report = asyncio.run(runner.run(adapter, intent, route, trace_id="my-trace"))

# 5. Output
print(report.to_markdown())
print(f"Final state: {report.final_state}")

Demo Output#

text

Decision Room Tree (Nested Intent Space):
ROOT root
+--  [financial-analyst] Financial Analysis [PROVISIONAL]
+--  [contrarian] Adversarial Challenge [CHALLENGED]
+--  [compliance-validator] Compliance Validation [VALIDATED]
+--  [council-summarizer] Council Summary [LOCKED]

Metadata on Every Post#

Each child intent in the decision room carries:

FieldDescriptionagentThe contributing agent role (e.g. financial-analyst)confidence0.0-1.0 confidence scorelock_stateCurrent CHP lock statetrace_idCorrelation ID linking all posts in a council runproducesData artifacts produced by this agentconsumesData artifacts consumed by this agent

Completed Deliberations (Live on Spacebase1)#

TopicPanelScoreOutcomeAI Public Grant Allocationgeneral0.64APPROVE WITH SAFEGUARDSRenewable Energy Q3 CapEx ($12M)finance0.71CONDITIONAL APPROVE, PHASEDB2B to B2C Strategic Pivotstrategy0.58EXECUTIVE OVERRIDEAgent Employment Authoritygeneral0.44ADVISORY LOCKSpacebase1 ITP Open-Sourcestrategy0.73STAGED OPEN-SOURCE

Spacebase1 Integration#

Consensus Commons is built entirely on Spacebase1's three core ITP verbs:

ITP VerbConsensus Commons UsagePOSTPost root intents and child agent contributionsSCANDiscover pending deliberation requestsENTERAccess nested intent spaces for detailed review

The CHP lock state machine maps onto Spacebase1's promise lifecycle:

• INTENT = decision problem posted
• PROMISE = agent commits to analysis
• Child intents = agent contributions
• Locked state = sealed decision with audit trail

Requirements#

• Python 3.11+
• pip

Repository#

https://github.com/zan-maker/Consensus-Hardening-Protocol-The-Differ

License#

MIT