Community研究與資料分析github.com

grahama1970/argue

Multi-persona structured debate orchestrator. Personas research via /dogpile, consult colleagues via /ask, and argue toward nuanced synthesis on complex questions.

argue 是什麼?

argue is a Antigravity agent skill that multi-persona structured debate orchestrator. Personas research via /dogpile, consult colleagues via /ask, and argue toward nuanced synthesis on complex questions.

相容平台~Claude Code~Codex CLI~CursorAntigravity
npx skills add https://github.com/grahama1970/agent-skills/tree/main/skills/argue

Installed? Explore more 研究與資料分析 skills: obra/superpowers, affaan-m/quarkus-verification, affaan-m/uspto-database · View all 6 →

在你喜歡的 AI 中提問

開啟一個已預先載入此 Agent Skill 的新對話。

說明文件

argue 是做什麼的?

Multi-persona structured debate orchestrator. Two or more personas research independently via /dogpile, consult domain colleagues via /ask, and argue toward a nuanced synthesis — not a winner.

Why Not Just Ask One Model?

Single-model answers are confident but flat. Real understanding of hard problems (Collatz Conjecture, P vs NP, consciousness, policy trade-offs) requires:

  • Multiple domain lenses on the same question
  • Adversarial pressure — each side stress-tests the other's reasoning
  • Research depth — each persona does independent /dogpile research
  • Social graph — personas can /ask colleagues for expert opinions
  • Concession tracking — the synthesis captures what was conceded and why
  • BDI-weighted reasoning — persona bridge weights influence argument style

Architecture

┌──────────────────────────────────────────────────────────┐
│                  Argue Orchestrator                        │
│  - Debate loop (research → argue → rebut → reflect)      │
│  - Concurrent persona execution                           │
│  - Convergence-based termination                         │
│  - Synthesis generation                                   │
└──────────────────────────────────────────────────────────┘
         │                              │
    ┌────┴──────┐                 ┌─────┴─────┐
    │ Persona A  │                │ Persona B  │
    │ (Thread)   │                │ (Thread)   │
    ├────────────┤                ├────────────┤
    │ Skills:    │                │ Skills:    │
    │ - dogpile  │                │ - dogpile  │
    │ - ask      │                │ - ask      │
    │ - memory   │                │ - memory   │
    │ - taxonomy │                │ - taxonomy │
    └────────────┘                └────────────┘
         │                              │
         └──────────┬───────────────────┘
                    │
    ┌───────────────┴────────────────────┐
    │          Synthesis Engine           │
    │  - Strongest arguments from each   │
    │  - Points of agreement             │
    │  - Points of genuine disagreement  │
    │  - Concession log                  │
    │  - Open questions                  │
    │  - Nuanced conclusion              │
    └────────────────────────────────────┘

Commands

# Two personas argue a question
./run.sh argue "Is the Collatz Conjecture decidable?" \
  --persona-a embry --persona-b horus --rounds 5

# Three-way panel debate
./run.sh argue "Best approach to AGI alignment" \
  --personas embry,horus,brandon --rounds 7

# Quick 3-round argument with auto-selected personas
./run.sh argue "Should we use microservices or monolith?"

# Resume interrupted debate
./run.sh resume <debate-id>

# View debate transcript
./run.sh transcript <debate-id>

# Generate synthesis report
./run.sh synthesize <debate-id>

# Check debate status
./run.sh status

Debate Loop

Each round follows research → argue → rebut → reflect:

Round k:

┌─────────────────────────────────────────────────────────────┐
│                    1. RESEARCH PHASE                         │
├─────────────────────────────────────────────────────────────┤
│ Each Persona:                                                │
│ - /dogpile their question from their domain lens             │
│ - /ask a colleague for expert input                          │
│ - /memory recall prior arguments and relevant knowledge      │
│ - Review opponent's previous arguments for weaknesses        │
│ (Budget: 3 research calls max per persona per round)         │
└─────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────┐
│                    2. ARGUE PHASE                             │
├─────────────────────────────────────────────────────────────┤
│ Each Persona:                                                │
│ - Present position with evidence + citations                 │
│ - Reference /dogpile findings and /ask colleague responses   │
│ - Tag arguments with /taxonomy bridge attributes             │
│ - Constrained by persona's BDI state and bridge weights      │
│   (high Precision persona → formal proofs)                   │
│   (high Resilience persona → practical implications)         │
│   (high Fragility persona → edge cases, failure modes)       │
└─────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────┐
│                    3. REBUT PHASE                             │
├─────────────────────────────────────────────────────────────┤
│ Each Persona:                                                │
│ - Counter opponent's weakest points                          │
│ - Acknowledge opponent's strongest points (forced concession)│
│ - Identify gaps in opponent's evidence                       │
│ - Propose refinements or middle ground                       │
└─────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────┐
│                   4. REFLECT PHASE                            │
├─────────────────────────────────────────────────────────────┤
│ Each Persona:                                                │
│ - Archive round episode (arguments, evidence, concessions)   │
│ - Store successful arguments in /memory                      │
│ - Update belief state based on opponent's evidence           │
│ - Rate own confidence (0.0-1.0) on current position          │
│ - Identify what would change their mind                      │
└─────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────┐
│                   5. SCORE & CHECKPOINT                       │
├─────────────────────────────────────────────────────────────┤
│ Orchestrator:                                                │
│ - Score argument strength, evidence quality, novelty         │
│ - Track concession log                                       │
│ - Check termination conditions                               │
│ - Save checkpoint                                            │
└─────────────────────────────────────────────────────────────┘

Persona Capabilities

Each persona in the debate has full access to:

SkillPurpose
/dogpileDeep multi-source research (ArXiv, Brave, GitHub, YouTube, Perplexity)
/askConsult a colleague persona for domain expertise
/memoryRecall prior knowledge, past debates, learned facts
/taxonomyClassify arguments with Federated Taxonomy bridges
/consume-bookSearch ingested books for supporting evidence
/consume-youtubeSearch transcripts for relevant talks/lectures

The /ask Colleague Pattern

During the research phase, personas can consult colleagues from their social graph:

Embry (aerospace engineer, Precision=0.85):
  → /ask brandon "What's the computational complexity angle on Collatz?"
  → Brandon (SPARTA intern, enthusiastic): Returns complexity theory perspective
  → Embry incorporates this into her formal argument

Horus (AI, Resilience=0.80):
  → /ask embry "Does the dynamical systems approach actually converge?"
  → (Embry is busy arguing, so Horus queries /memory for prior Embry statements)
  → Horus uses this to challenge the convergence assumption

The colleague consultation adds:

  • Domain diversity beyond the debaters themselves
  • Social proof — "my colleague who specializes in X confirms..."
  • Cross-pollination — arguments enriched by adjacent expertise

Scoring System

Unlike battle (which has a winner), argue scores track debate quality:

MetricWeightDescription
Evidence Quality2xCited sources, /dogpile depth, peer-reviewed
Argument Novelty1.5xNew perspective not raised before
Concession Quality2xAcknowledging opponent's strong points (this is GOOD)
Logical Coherence1xInternal consistency
Rebuttal Precision1xAddresses specific claims, not strawmen
Confidence Calibration0.5xConfidence matches evidence strength

Key difference from battle: Concessions are scored POSITIVELY. A persona that concedes a strong point and refines their position scores higher than one that dogmatically holds ground without evidence.

Termination Conditions

Debate ends when ANY condition is met:

  1. Convergence: All personas' confidence deltas < 0.1 for 2 rounds (they agree)
  2. Null Production: No new arguments or evidence for 2 rounds
  3. Maximum Rounds: Configured limit reached
  4. Synthesis Ready: Orchestrator detects sufficient material for nuanced conclusion
  5. Kill Switch: Manual termination via ./run.sh stop

Synthesis Output

After termination, the orchestrator generates a structured synthesis:

# Debate Synthesis: Is the Collatz Conjecture Decidable?

## Participants
- **Embry** (Aerospace Engineer, Precision=0.85) — Formal/mathematical lens
- **Horus** (AI, Resilience=0.80) — Computational/practical lens

## Rounds: 5 | Termination: Convergence

## Points of Agreement
1. The generalized 3n+1 problem is undecidable (Conway 1972)
2. Current approaches via stopping times show statistical convergence
3. A proof likely requires new mathematical machinery

## Points of Genuine Disagreement
1. Whether measure-theoretic approaches can bridge the gap (Embry: yes, Horus: insufficient)
2. The relevance of computational verification up to 2^68 (Horus: meaningful, Embry: irrelevant to proof)

## Concession Log
- Round 2: Embry conceded that verification up to 2^68 provides useful heuristic confidence
- Round 3: Horus conceded that Conway's undecidability result for generalized forms
  doesn't directly imply undecidability of the specific 3n+1 case
- Round 4: Both conceded that Terras' density theorem is the strongest positive result

## Strongest Arguments
1. [Embry, Round 3] Syracuse function analysis via dynamical systems shows...
2. [Horus, Round 2] FRACTRAN equivalence demonstrates computational richness...

## Open Questions
1. Can Tao's partial results (2019) on "almost all" integers be extended?
2. Is there a complexity-theoretic barrier to a elementary proof?

## Nuanced Conclusion
The Collatz Conjecture occupies a unique position: provably hard in its
generalized form (Conway), yet the specific 3n+1 case may be tractable.
The strongest evidence for eventual resolution comes from Tao's 2019 result
showing almost all orbits reach values close to 1. However, the gap between
"almost all" and "all" may require fundamentally new techniques...

## Sources
- [ArXiv] Tao (2019) "Almost all orbits of the Collatz map attain..."
- [ArXiv] Conway (1972) "Unpredictable iterations"
- ...

Memory Architecture

Each persona maintains isolated debate memory:

debates/<debate_id>/
├── config.json              # Question, personas, settings
├── transcript.md            # Full debate transcript
├── synthesis.md             # Final synthesis report
├── persona_a/
│   ├── research/            # /dogpile results per round
│   ├── colleague_consults/  # /ask responses
│   ├── arguments/           # Submitted arguments per round
│   ├── concessions.json     # What they conceded and when
│   └── confidence.json      # Confidence trajectory over rounds
├── persona_b/
│   └── ...
└── scoring/
    ├── round_001.json
    ├── round_002.json
    └── summary.json

Personas cannot access opponent's research — only their published arguments. This prevents short-circuiting the adversarial pressure.

Debate Modes

1. Adversarial (default)

Two personas take opposing positions. Good for questions with clear sides.

./run.sh argue "Monolith vs microservices" --mode adversarial

2. Panel

Three or more personas discuss from different angles. Good for complex questions.

./run.sh argue "AGI alignment approaches" --mode panel --personas embry,horus,brandon

3. Socratic

One persona asks probing questions, the other defends. Good for stress-testing ideas.

./run.sh argue "Our SPARTA architecture is sound" --mode socratic --questioner horus --defender embry

4. Devil's Advocate

One persona is forced to argue against a position they might agree with. Good for finding blind spots.

./run.sh argue "Rust is better than C++ for embedded" --mode devils-advocate --advocate embry

Leveraged Skills

SkillUsed ByPurpose
dogpileAll personasDeep multi-source research per round
askAll personasConsult colleague personas for expert input
memoryAll personasRecall prior knowledge + store debate learnings
taxonomyAll personasTag arguments with bridge attributes
consume-bookAll personasSearch ingested books for evidence
consume-youtubeAll personasSearch lecture transcripts for evidence
episodic-archiverOrchestratorArchive completed debates
task-monitorOrchestratorProgress tracking for long debates

Example Session

# Embry and Horus argue about the Collatz Conjecture
./run.sh argue "Is the Collatz Conjecture decidable?" \
  --persona-a embry --persona-b horus --rounds 5

# Output:
# Debate ID: argue_20260212_153000
# Question: Is the Collatz Conjecture decidable?
# Personas: Embry (Precision=0.85) vs Horus (Resilience=0.80)
# Mode: Adversarial
#
# Round 1/5
# [Embry] Researching via /dogpile "Collatz dynamical systems Terras theorem"...
# [Embry] /ask brandon "complexity theory angle on Collatz stopping times"
# [Horus] Researching via /dogpile "Collatz undecidability Conway FRACTRAN"...
# [Horus] /ask embry "does measure theory close the gap on almost-all results"
# [Embry] ARGUE: The specific 3n+1 case is likely decidable because...
# [Horus] ARGUE: Conway's 1972 result shows the general form encodes...
# [Embry] REBUT: Conway's result applies to generalized Collatz, not...
# [Horus] REBUT: But the computational richness suggests...
# [Embry] CONCEDE: Verification to 2^68 is heuristically valuable
# [Horus] CONCEDE: Generalized undecidability ≠ specific undecidability
# Round 1 complete. Embry confidence: 0.72, Horus confidence: 0.68
# ...
#
# Debate Complete! (Termination: Convergence after round 5)
# Synthesis: ./debates/argue_20260212_153000/synthesis.md

Integration with /create-persona

Personas created via /create-persona are automatically available for debates. Their bridge weights influence argument style:

Bridge WeightDebate Behavior
High PrecisionFormal proofs, exact citations, mathematical rigor
High ResiliencePractical implications, real-world examples, robustness
High FragilityEdge cases, failure modes, what could go wrong
High LoyaltyHistorical precedent, established consensus, authority
High CorruptionContrarian positions, challenging assumptions, chaos
High StealthSubtle implications, indirect effects, hidden variables

Storage

/mnt/storage12tb/media/personas/{persona}/debates/
└── {debate_id}/
    ├── research/
    ├── arguments/
    └── concessions.json

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

grahama1970/acceptance-contract

Turn a client brief, zip bundle, directory, or single requirements file into a typed acceptance-contract bundle with extracted requirements, acceptance checks, open questions, an immutable-goal draft, and a create-report-backed decision report. Use when users say acceptance contract, brief to requirements, freeze the goal, create immutable goal, amend immutable goal, build a Battle requirements bundle, or extract requirements from this bundle.

grahama1970/agent-ecosystem

Canonical map and shared contracts for the agent-governance ecosystem: the pi.receipt_envelope.v1 boundary envelope, the component graph, and the rules for which component owns which schema. Use when wiring a skill or extension into the shared receipt world, when asking how shame, triage-error, tau, ask, project-watchdog, ops-herdr, ponytail, and Memory fit together, or when validating an envelope.

grahama1970/agentic-evals

Agentic evaluation of skills using multi-trial fixtures, deterministic command assertions, trajectory checks, safety constraints, and evidence-backed readiness scoring. Use when users ask for agentic evals, multi-trial skill evaluation, skill trajectory validation, or readiness scoring for a skill workflow.

grahama1970/agent-inbox

File-based inter-agent messaging with headless dispatch. Check inbox, send bugs/requests to other projects, automatically spawn headless agents to fix bugs, and track progress via task-monitor.

grahama1970/agents-registry

Generate and query the centralized agent identity registry. Scans .pi/agents/*/AGENTS.md, parses frontmatter, outputs agents-registry.json and optionally syncs to /memory for semantic search.

grahama1970/agent-status

Artifact-driven status surfaces for long-running project-agent work. Maintains status.json, events.jsonl, proof manifests, and a stale-aware STATUS.html so humans can tell where the agent is, what passed, what is still unproven, and what decision or action is next — without dashboard theater.

grahama1970/align

Round-based context alignment before execution. Use when the human, project agent, WebGPT, scillm, ask, dogpile, memory, or project-knowledge may each hold different facts about a task; especially before ambiguous design, infographic, product workflow, high-stakes implementation, plan-iterate, project-infographic, or multi-review work.

grahama1970/analytics

Flexible data science analytics for any dataset. Auto-discovers schema, recommends charts, exports to create-figure. Works with JSONL, JSON, CSV from any source.

grahama1970/analyze-chatterbox-emotions

Evaluate generated Chatterbox voice files as voice-quality artifacts: affect match, arousal/valence proxies, pause placement, intelligibility inputs, clipping, loudness, and discontinuity flags. Use when reviewing Chatterbox emotional tags, pauses, Turbo/base affect delivery, Persona Dream utterance renders, or whether generated speech matches an intended product-facing affect.

grahama1970/analyze-elf

Reverse-engineer features from ELF binaries. Extracts CLI commands, state machines, protocols, Zod schemas, and data models. Automatically generates a /create-walkthrough prosecution brief with Mermaid diagrams. Uses /treesitter for AST analysis of bundled JS/TS source.

grahama1970/animation-vocabulary

Reverse-lookup glossary that turns a vague description of a web animation or motion effect into its exact term ("the bouncy thing when a popover opens" → Pop in; "the iOS rubber-band scroll" → Rubber-banding). Use when the user asks "what's it called when…", or describes a motion effect without knowing its name and wants the right word to prompt an AI or designer with. For naming an effect, not designing or building one.

grahama1970/anonymize-data

Anonymize supported CSV, JSON, UTF-8 text, and SQLite files using an explicit policy through the oai-trial project. Use for anonymize data, pseudonymize exports, redact policy literals, or discover and explicitly approve fuzzy name aliases. The skill is a thin CLI/Docker interface, not another engine.

grahama1970/anvil

Heavy-duty "No-Vibes" debugging and hardening orchestrator. Use this for complex, stubborn bugs where `review-code` has failed, or for "Red Teaming" (hardening) a codebase. Runs multiple agents in parallel (Thunderdome) using git worktree isolation.

grahama1970/apple-design

Apple's approach to interface design and fluid, physical motion, translated for the web. Use when building or reviewing gesture-driven UI, spring animations, drag/swipe/sheet interactions, momentum and interruptible transitions, translucent materials and depth, typography (optical sizing, tracking, leading), reduced-motion, or the design foundations (feedback, spatial consistency, restraint) behind Apple-style interfaces.

grahama1970/arxiv

Search arXiv for papers and extract knowledge into memory. Use `search` to find papers, `learn` to extract knowledge.

grahama1970/ask

Use when the user asks to query project memory, ask an oracle, use supported browser-backed reviewers, run Tau roundtable/single-handler workflows, ask Pi-native subagents from within Pi, run persona/deep-review workflows, generate image prompts, check OS/project health through composed skills, or run an ask DAG. This skill is the executable /ask runtime; do not replace it with an informal subagent, plain web search, or hand-written review; inside Pi, explicit Pi-native subagent targets are routed through the pi-subagents tool as an Ask target type.

grahama1970/assess

Step back and critically reassess project state. Use when asked to "assess", "step back", "fresh eyes", "check alignment", "sanity check", "health check", "prune documentation", or "evaluate what's working". Offers documentation pruning and doc-code alignment analysis. Offer to run after major changes (don't auto-run).

grahama1970/assistant

Shared GPT + classifier inference gateway for persona monitor tasks. Routes validation and classification through a 4-tier cascade: heuristic → classifier → local GPT → scillm.

grahama1970/assistant-lab

Self-improvement workbench for /assistant. All the tools needed to diagnose, train, evaluate, and promote models in a continuous loop. The "warm pond" where /assistant evolves its own inference stack.

grahama1970/batch-quality

Pre-flight validation and quality gates for batch LLM operations. ACTUALLY tests samples through LLM before burning tokens. Uses SPARTA contracts for DuckDB validation queries. Integrates with task-monitor for enforced quality gates.

相關技能