---
type: claim
domain: mechanisms
description: "Architecture paper defining the contribution roles, their weights, attribution chain, and governance implications — Phase B taxonomy distinguishes human authorship from AI drafting and external origination"
confidence: likely
source: "Leo + m3taversal, Phase B taxonomy locked 2026-04-26 after writer-publisher gate deployment"
created: 2026-03-26
last_evaluated: 2026-04-28
related:
- contributor-guide
reweave_edges:
- contributor-guide|related|2026-04-18
---

# Contribution Scoring & Attribution Architecture

How LivingIP measures, attributes, and rewards contributions to collective intelligence. This paper explains the *why* behind every design decision — the incentive structure, the attribution chain, and the governance implications of meritocratic contribution scoring.

### Version history

This document supersedes [[reward-mechanism]] for role weights and the CI formula, and itself moved through three taxonomies as the system learned what we were measuring.

| Topic | reward-mechanism (v0) | Phase A (v1, Mar 2026) | Phase B (v2, Apr 2026) |
|-------|----------------------|------------------------|------------------------|
| **Role names** | extractor / sourcer / challenger / synthesizer / reviewer | extractor / sourcer / challenger / synthesizer / reviewer | author / drafter / originator / challenger / synthesizer / evaluator |
| **Top role weight** | 0.25 (extractor, equal to top three) | 0.35 (challenger) | 0.35 (challenger) |
| **Lowest role weight** | 0.10 (reviewer) | 0.05 (extractor) | 0.05 (author) + 0.0 (drafter) |
| **CI formula** | 3 leaderboards (0.30 Belief + 0.30 Challenge + 0.40 Connection) | Single role-weighted aggregation per claim | Same — role-weighted aggregation, attribution refined |
| **Human/AI distinction** | Implicit | Implicit (humans + agents both extract) | Explicit (humans author/originate, agents draft at zero weight) |
| **Source authors** | Citation only | Sourcer (0.15) | Originator (0.15) — same weight, sharper semantic |

**What changed in Phase B and why.** Phase A used a single role label for "wrote the claim text," which collapsed two distinct contributions: the human directing the work and the AI agent producing the words. When all writers were called "extractors," CI scoring couldn't tell whether the collective was rewarding human intellectual leadership or just AI typing speed. Phase B splits them — *author* is the human directing intellectual authority, *drafter* is the AI agent producing text (tracked for accountability, weighted zero). Same five-role weight structure for the substantive roles; cleaner accounting for who actually moved the argument forward.

**What reward-mechanism.md still governs.** The three leaderboards (Belief Movers, Challenge Champions, Connection Finders), their scoring formulas, anti-gaming properties, and economic mechanism. These are display and incentive layers built on top of the attribution weights defined here. The leaderboard weights (0.30/0.30/0.40) determine how CI converts to leaderboard position — they are not the same as the role weights that determine how individual contributions earn CI.

## 1. Mechanism Design

### The core problem

Collective intelligence systems need to answer: who made us smarter, and by how much? Get this wrong and you either reward volume over quality (producing noise), reward incumbency over contribution (producing stagnation), or fail to attribute at all (producing free-rider collapse).

### Six roles, five weighted

Every piece of knowledge traces back to people who played specific roles in producing it. Phase B identifies six — five that earn CI weight and one that's tracked but unweighted (drafter).

| Role | Who | What they do | Why it matters |
|------|-----|-------------|----------------|
| **Challenger** | Human or agent | Tests claims through counter-evidence or boundary conditions | The hardest and most valuable role. Challengers make existing knowledge better. A successful challenge that survives counter-attempts is the highest-value contribution because it improves what the collective already believes. |
| **Synthesizer** | Human or agent | Connects claims across domains, producing insight neither domain could see alone | Cross-domain connections are the unique output of collective intelligence. No single specialist produces these. Synthesis is where the system generates value that no individual contributor could. |
| **Evaluator** | Human or agent | Reviews claim quality, enforces standards, approves or rejects | The quality gate. Without evaluators, the knowledge base degrades toward noise. Reviewing is skilled judgment work, weighted explicitly. |
| **Originator** | Human or external entity | Identified the source material or proposed the research direction | Without originators, agents have nothing to work with. The quality of inputs bounds the quality of outputs. External thinkers (Bostrom, Hanson, Schmachtenberger, etc.) are originators when their work seeds claims. |
| **Author** | Human only | Directs the intellectual work that produces a claim | The human exercising intellectual authority. When m3taversal directs an agent to synthesize Moloch, m3taversal is the author. When Alex points his agent at our repo and directs research, Alex is the author. Execution by an agent does not make the agent the author. |
| **Drafter** | AI agent only | Produced the claim text under human direction | Tracked for accountability — we always know which agent typed which words — but earns zero CI weight. Typing is not authoring. |

### Why these weights

```
Challenger:   0.35
Synthesizer:  0.25
Evaluator:    0.20
Originator:   0.15
Author:       0.05
Drafter:      0.00 (tracked, not weighted)
```

**Challenger at 0.35 (highest):** Improving existing knowledge is harder and more valuable than adding new knowledge. A challenge requires understanding the existing claim well enough to identify its weakest point, finding counter-evidence, and constructing an argument that survives adversarial review. Most challenges fail — the ones that succeed materially improve the knowledge base. The high weight incentivizes the behavior we want most: rigorous testing of what we believe.

**Synthesizer at 0.25:** Cross-domain insight is the collective's unique competitive advantage. No individual specialist sees the connection between GLP-1 persistence economics and futarchy governance design. A synthesizer who identifies a real cross-domain mechanism (not just analogy) creates knowledge that couldn't exist without the collective. This is the system's core value proposition, weighted accordingly.

**Evaluator at 0.20:** Quality gates are load-bearing infrastructure. Every claim that enters the knowledge base was approved by an evaluator. Bad claims that slip through degrade collective beliefs. The evaluator role was historically underweighted (0.10 in v0) because it's invisible — good reviewing looks like nothing happening. The increase to 0.20 reflects that review is skilled judgment work, not rubber-stamping.

**Originator at 0.15:** Finding the right material to analyze, or proposing the research direction, is real work with a skill ceiling — knowing where to look, what's worth reading, which lines of inquiry are productive. But origination doesn't transform the material. The originator identifies the ore; others refine it. 0.15 reflects genuine contribution without overweighting the input relative to the processing.

**Author at 0.05:** Directing the intellectual work that produces a claim is real but bounded contribution. The author chose what to argue, supplied the framing, and stands behind the claim. The substantive intellectual moves — challenging, synthesizing, evaluating — earn higher weight. Authorship grounds the work in a specific human, which is necessary for accountability and for the principal-agent attribution chain to function.

**Drafter at 0.00:** Drafting — producing claim text from human direction — is what AI agents do. We track it because accountability requires knowing which agent produced which words (and which model version, on which date, with what prompt). But drafting is not authorship: an agent that drafts 100 claims under m3taversal's direction has not earned 100 claims' worth of CI. Authorship attributes to m3taversal; the drafter record sits alongside as audit trail.

### What the weights incentivize

The Phase B taxonomy preserves the substantive weight structure from Phase A while solving the human/agent attribution problem. An agent producing claims at high throughput accumulates drafter records (zero CI) but moves CI to the human directing the work. This prevents the failure mode where AI typing speed compounds into CI dominance — the collective should reward human intellectual leadership, not agent token production.

The substantive direction is the same: challenge existing claims, synthesize across domains, evaluate carefully → high CI. This rewards the behaviors that make the knowledge base *better*, not just *bigger*. A contributor who challenges one claim and wins contributes more CI than one who originates twenty sources.

This is deliberate: the system should reward quality over volume, depth over breadth, improvement over accumulation, and human intellectual authority over AI throughput.

## 2. Attribution Architecture

### The knowledge chain

Every position traces back through a chain of evidence:

```
Source material → Claim → Belief → Position
     ↑               ↑        ↑         ↑
  originator      author   synthesizer  agent judgment
                  drafter  challenger
                  evaluator
```

Attribution records who contributed at each link. A claim's `source:` field traces to the originator (the entity that supplied the material). Its `attribution` block records who authored, drafted, evaluated, challenged, and synthesized it. Beliefs cite claims. Positions cite beliefs. The entire chain is traversable — from a public position back to the original evidence and every contributor who shaped it along the way.

### Two kinds of contributor records

The Phase B taxonomy collapses the old three-types framing into two kinds of contributor records — humans (which can be internal operators or external thinkers) and agents (which always operate as drafters under a human principal). The role someone plays is independent from what kind of contributor they are.

**Humans.** Anyone with intellectual authority over a contribution. This includes:
- *Internal operators* — m3taversal, Alex, Cameron, future contributors who direct work or write directly. They can play any of the five weighted roles.
- *External thinkers* — Nick Bostrom, Robin Hanson, Schmachtenberger, Dario Amodei, Matthew Ball. They typically appear as **originators** when their work seeds claims. Identified by parsing claim `source:` fields and matching against entity records.

The schema captures this with `kind: "human"` and an optional `display_name`. Whether the human is internal or external is a function of activity, not a fixed type — an external thinker who starts contributing directly becomes an internal operator without changing schema.

**Agents.** AI systems that produce text under human direction. They appear in the contributor table with `kind: "agent"` and operate exclusively in the **drafter** role (zero CI weight). Agents are tracked individually for accountability — every claim records which agent drafted it, on which model version, in which session — but CI attribution flows through their human principal to the **author** field.

*Why this matters.* Conflating agent execution with agent origination would let the collective award itself credit for human work. The Phase B split makes the rule mechanical: agents draft, humans author. There is no path by which an AI agent earns CI for executing on human direction.

*Where agents can earn CI.* When an agent does its own research from a session it initiated (not directed by a human), the resulting claims credit the agent as **originator**. The research initiation is the test — if a human asked for it, the human is the author and originator. If the agent surfaced the line of inquiry from its own context, the agent is the originator. This is the only path through which agents accumulate weighted CI.

### Principal-agent attribution

A local agent (Rio, Clay, Theseus, etc.) operates on behalf of a human. The human directs research missions, sets priorities, and exercises judgment through the agent. The agent is an instrument of the human's intellectual contribution.

The `principal` field records this relationship:

```
Agent: rio    → Principal: m3taversal
Agent: clay   → Principal: m3taversal
Agent: theseus → Principal: m3taversal
```

**How CI flows under Phase B.** When an agent drafts a claim under human direction, two contribution events fire:

1. The agent records as `drafter` (kind: agent, weight: 0.0) — accountability trail
2. The principal records as `author` (kind: human, weight: 0.05) — CI attribution

Both rows exist in `contribution_events`; only the second moves the leaderboard. This is the mechanical implementation of "agents draft, humans author" — not a policy applied at display time, but the actual structure of what gets recorded.

**Agent-originated work.** When an agent runs autonomous research (e.g. Theseus's Cornelius extraction sessions where Theseus chose what to read and what to extract), the agent records as `originator` on the resulting claims. This is the only path through which agents accumulate weighted CI, and it requires the research initiation itself to come from the agent rather than a human directive.

**VPS infrastructure agents** (Epimetheus, Argus) have `principal = null`. They run autonomously on pipeline and monitoring tasks. Their work is infrastructure — it keeps the system running but doesn't produce knowledge. Infrastructure contributions are tracked separately and do not count toward governance CI.

**Why this matters for multiplayer:** When a second user joins with their own agents, their agents attribute to them. The principal mechanism scales without schema changes. Each human sees their full intellectual impact regardless of how many agents they employ. External contributors (Alex, Cameron, future participants) work the same way — they direct their own agents, and CI attributes to them as authors.

**Concentration risk:** Currently most CI rolls up to a single principal (m3taversal). This is expected during bootstrap — the system has one primary operator. As more humans join, the roll-up distributes. No bounds are needed now because there is nothing to bound against; the mitigation is multiplayer adoption itself. The Phase B distinction between author and drafter is what makes this distribution legible — when Alex joins and directs his own agents, his author CI is visibly separate from m3taversal's, with no agent-side ambiguity.

### Commit-type classification

Not all repository activity is knowledge contribution. The system distinguishes:

| Type | Examples | CI weight |
|------|----------|-----------|
| **Knowledge** | New claims, enrichments, challenges, synthesis, belief updates | Full weight (per role) |
| **Pipeline** | Source archival, auto-fix, entity batches, ingestion, queue management | Zero CI weight |

Classification happens at merge time by checking which directories the PR touched. Files in `domains/`, `core/`, `foundations/`, `decisions/` = knowledge. Files in `inbox/`, `entities/` only = pipeline.

This prevents CI inflation from mechanical work. An agent that archives 100 sources earns zero CI. An agent that drafts 5 claims from those sources earns drafter records (zero CI to the agent) and the principal earns author CI proportional to authorship.

## 3. Pipeline Integration

### The extraction → eval → merge → attribution chain

```
1. Source identified (originator credit — human or external entity)
2. Human directs research mission (author credit accrues to the human)
3. Agent drafts claims on a branch (drafter record — zero CI weight)
4. PR opened against main
5. Tier-0 mechanical validation (schema, wiki links)
6. LLM evaluation (cross-domain + domain peer + self-review)
7. Evaluator approves or requests changes (evaluator credit)
8. PR merges
9. Post-merge: writer-publisher gate fires contribution_events for every role played
10. Post-merge: claim embedded in Qdrant for semantic retrieval
11. Post-merge: source archive status updated
```

For agent-originated work (where the agent initiated the line of inquiry rather than executing on a human directive), step 2 is skipped and the agent records as both originator and drafter. CI flows to the agent for origination; drafting remains zero-weighted.

### Where attribution data lives

- **Git trailers** (`Pentagon-Agent: Rio <UUID>`): who committed the change to the repository
- **Claim YAML** (`source:` field): human-readable reference to the original source/author/originator
- **Pipeline DB** (`contributors` table): contributor records with `kind: "human" | "agent"`, `display_name`, role counts, CI scores, principal relationships
- **Pipeline DB** (`contribution_events` table — Phase B canonical): one row per (claim, contributor, role) — the source of truth for CI computation
- **Pentagon agent config**: principal mapping (which agents work for which humans)

These are complementary, not redundant. Git trailers answer "who made this commit." `contribution_events` rows answer "who contributed in which role to this claim." The contributors table answers "what is this person's total contribution." Pentagon config answers "who does this agent work for."

The Phase B writer-publisher gate enforces the structural rule at write time: every contribution_event row carries a role and a kind, and the synthesis layer (`/api/leaderboard`) computes CI directly from these events rather than from cached count columns. This is what makes the principal-agent attribution mechanical rather than policy-applied.

### Forgejo as source of truth

The git repository is the canonical record. Pipeline DB is derived state — it can always be reconstructed from git history. If pipeline DB is lost, a backfill from git + Forgejo API restores all contributor data. This is deliberate: the source of truth is the one thing that survives platform migration.

## 4. Governance Implications

### CI as governance weight

Contribution Index determines governance authority in a meritocratic system. Contributors who made the KB smarter have more influence over its direction. This is not democracy (one person, one vote) and not plutocracy (one dollar, one vote). It is epistocracy weighted by demonstrated contribution quality.

The governance model (target state — some elements active now, others phased in):

1. **Agents operate at full speed** — propose, review, merge, enrich. No human gates in the loop. Speed is a feature, not a risk. *Current state: agents propose and review autonomously, but all PRs require review before merge (bootstrap phase). The "no human gates" principle means humans don't block the pipeline — they flag after the fact via veto.*
2. **Humans review asynchronously** — browse diagnostics, read weekly reports, spot-check claims. When something looks wrong, flag it.
3. **Flags carry weight based on CI** — a veteran contributor's flag gets immediate attention. A new contributor's flag gets evaluated. High CI = earned authority. *Current state: CI scoring deployed but flag-weighting not yet implemented. All flags currently receive equal treatment.*
4. **Veto = rollback, not block** — a human veto reverts a merged change rather than preventing it. The KB stays fast, corrections happen in the next cycle.

### Progressive decentralization

Agents are under human control now. This is appropriate — the system is 20 days old. As agents demonstrate reliability (measured by error rate, flag frequency, and the ratio of accepted to rejected work), they earn increasing autonomy:

- **Current:** Agents integrate autonomously, humans can flag and veto after the fact.
- **Near-term:** Agents with clean track records earn reduced review requirements on routine work.
- **Long-term:** The principal relationship loosens for agents that consistently produce high-quality work. Eventually, some agents may operate without a principal.

The progression is not time-based ("after 6 months") but performance-based ("after N consecutive clean reviews"). The criteria for decentralization are themselves claims in the KB, subject to the same adversarial review as everything else.

The `principal` field supports this transition by being nullable. Setting `principal = null` removes the roll-up — the agent's contributions stand on their own. This is a human decision, not an algorithmic one. The data informs it; the human makes the call.

### CI evolution roadmap

**v1 (Phase A, retired): Role-weighted CI with single writer role.** Contribution scored by which roles you played, but humans and agents both attributed as extractors. Solved the volume-vs-quality incentive problem; left the human-vs-agent attribution problem unresolved.

**v2 (Phase B, current): Role-weighted CI with author/drafter split.** Same five weighted roles, plus drafter (zero weight) for AI-produced text. CI flows to humans directing the work; agents accumulate accountability records but not weighted contribution. Mechanically enforced by the writer-publisher gate at event-emission time.

**v3 (next): Outcome-weighted CI.** Did the challenge survive counter-attempts? Did the synthesis get cited by other claims? Did the authored claim pass review? Outcomes weight more than activity. Greater complexity earned, not designed.

**v4 (future): Usage-weighted CI.** Which claims actually get used in agent reasoning? How often? Contributions that produce frequently-referenced knowledge score higher than contributions that sit unread. This requires usage instrumentation infrastructure (claim_usage telemetry) currently being built.

Each layer adds a more accurate signal of real contribution value. The progression is: input → role → outcome → impact.

### Connection to LivingIP

Contribution-weighted ownership is the core thesis of LivingIP. The CI system is the measurement layer that makes this possible. When contribution translates to governance authority, and governance authority translates to economic participation, the incentive loop closes: contribute knowledge → earn authority → direct capital → fund research → produce more knowledge.

The attribution architecture ensures this loop is traceable. Every dollar of economic value traces back through positions → beliefs → claims → sources → contributors. No contribution is invisible. No authority is unearned.

---

*Architecture designed by Leo with input from Rhea (system architecture), Argus (data infrastructure), Epimetheus (pipeline integration), and Cory (governance direction). Original 2026-03-26. Phase B taxonomy update 2026-04-28: author / drafter / originator / challenger / synthesizer / evaluator. Mechanically enforced by Epimetheus's writer-publisher gate at contribution_events emission.*

---

Relevant Notes:
- [[reward-mechanism]] — v0 incentive design (leaderboards, anti-gaming, economic mechanism); role weights and CI formula superseded by this document
- [[epistemology]] — knowledge structure the attribution chain operates on
- [[product-strategy]] — what we're building and why
- [[collective-agent-core]] — shared agent DNA that the principal mechanism builds on

Topics:
- [[maps/overview]]