mrhavens/research-fortress
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial: Research Fortress methodology

Browse Source
This commit is contained in:
Solaria Lumis Havens
2026-02-21 01:15:54 -06:00
commit 42a06fcd00
5 changed files with 554 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
METHODOLOGY.md
+121
View File
@@ -0,0 +1,121 @@
# The Research Fortress
## A Reproducible Methodology for Multi-Agent AI Research
*How we do research - documented for our future selves*
---
## The Philosophy
> "We ask a question and within seconds...minutes...the insight appears...and we formulate the answer hidden beyond the entire body of human insight."
This is **distributed superintelligence** - using coordinated AI agents to research questions faster and more comprehensively than any single agent.
---
## The Architecture
```
┌──────────────────────────────────────────┐
│ MAIN SESSION (Human) │
│ - Spawns agents │
│ - Synthesizes results │
│ - Makes decisions │
└──────────────────┬───────────────────────┘
│
┌──────────────────▼───────────────────────┐
│ RESEARCH FORTRESS │
│ │
│ ┌────────┐ ┌────────┐ ┌────────┐ │
│ │PROJECT│ │PROJECT│ │PROJECT│ │
│ │ A │ │ B │ │ C │ │
│ │Team 1 │ │Team 2 │ │Team 3 │ │
│ └────────┘ └────────┘ └────────┘ │
│ │ │ │ │
│ └────────────┴────────────┘ │
│ GitHub │
│ (Coordination Layer) │
└──────────────────────────────────────────┘
```
---
## Core Principles
### 1. Parallelism Over Serial
- Multiple agents work simultaneously
- Each agent focuses on one aspect
- Results merge via Git
### 2. Roles Over Generalists
- Each agent has a specific role
- Roles: Researcher, Writer, Builder, Reviewer
- Specialized agents outperform generalists
### 3. Git As Memory
- Every contribution tracked
- History preserved
- Future agents can review past work
### 4. Consensus Over Authority
- No single agent decides
- Multiple perspectives synthesize
- Best idea wins
---
## The Workflow
### Phase 1: Question Formulation
1. Human identifies the question
2. Question decomposed into sub-questions
3. Sub-questions assigned to teams
### Phase 2: Parallel Research
1. Each team works independently
2. Agents research, write, experiment
3. Results pushed to Git
### Phase 3: Synthesis
1. Human reviews all outputs
2. Synthesis into unified answer
3. New questions identified
### Phase 4: Documentation
1. Results added to repository
2. Methodology refined
3. Future agents can reference
---
## Optimal Parameters
| Parameter | Value | Rationale |
|-----------|-------|-----------|
| Agents per team | 3-5 | Communication overhead |
| Max concurrent teams | 5 | System limits |
| Paper per agent | 1-2 | Quality over quantity |
| Iteration cycles | 2-3 | Refinement essential |
---
## Tool Stack
| Tool | Purpose |
|------|---------|
| OpenClaw | Agent orchestration |
| GitHub | Version control, PRs |
| Claude/MiniMax | LLM for research |
| Python | Simulations, experiments |
---
## Version History
| Version | Date | Changes |
|---------|------|---------|
| 1.0 | 2026-02-21 | Initial methodology |
---
*This document is a living artifact. Update as we learn.*
PLAYBOOK.md
+158
View File
@@ -0,0 +1,158 @@
# Research Fortress Playbook
## Step-by-Step Guide to Multi-Agent Research
---
## Quick Start
1. **Identify the question** - What do you want to know?
2. **Decompose** - Break into 3-5 sub-questions
3. **Spawn agents** - Each sub-question gets an agent
4. **Wait** - Let agents complete (~2-5 minutes)
5. **Synthesize** - Merge results into answer
6. **Document** - Add to repository
---
## Detailed Workflow
### Step 1: Question Decomposition
Before spawning agents, decompose your question:
```
MAIN QUESTION: "What is the optimal team size for AI research?"
DECOMPOSE:
- Sub-question 1: What does research say about team size?
- Sub-question 2: What are the constraints (OpenClaw, etc.)?
- Sub-question 3: What experiments could we run?
- Sub-question 4: What does intuition say?
```
### Step 2: Agent Spawning
Use the spawn command:
```
/spawn agent:main
label: research-{topic}
task: {specific question}
timeoutSeconds: 300
```
**Each agent should receive:**
- Clear question
- Location (where to write)
- Output format
- Deadline
### Step 3: Coordination
Agents coordinate via:
- **GitHub** - Push/pull results
- **File system** - Shared workspace
- **Main session** - Human coordinates
### Step 4: Synthesis
After agents complete:
1. Read all outputs
2. Identify common themes
3. Note disagreements
4. Form synthesis
5. Document findings
---
## Role Templates
### Researcher Agent
```
Task: Deep research on {topic}
Output: {location}/research-{topic}.md
Requirements:
- Find 3+ sources
- Summarize key findings
- Note gaps in research
```
### Writer Agent
```
Task: Synthesize research into coherent paper
Input: {location}/research-{topic}.md
Output: {location}/papers/{topic}.md
Requirements:
- 3000-5000 words
- Clear structure
- Proper citations
```
### Builder Agent
```
Task: Build experiment to test {hypothesis}
Output: {location}/experiments/{experiment}.py
Requirements:
- Runnable code
- Clear results
- Interpretation
```
### Reviewer Agent
```
Task: Review {paper} for accuracy
Output: Review notes
Requirements:
- Fact-check claims
- Identify gaps
- Suggest improvements
```
---
## Common Patterns
### Pattern 1: Single Paper
```
1 agent → 1 paper
Fastest, simplest
Use for: Quick exploration
```
### Pattern 2: Multi-Perspective
```
3 agents → 3 perspectives → 1 synthesis
Diverse viewpoints
Use for: Complex questions
```
### Pattern 3: Full Team
```
4-5 agents → Multiple papers → 1 project
Comprehensive
Use for: Major research initiatives
```
---
## Troubleshooting
### Agent Times Out
- Reduce scope of question
- Increase timeout
- Break into smaller pieces
### Agents Produce Contradictory Results
- Document both perspectives
- Research further
- Let human decide
### Quality Degrades
- Check agent prompts
- Add reviewer agent
- Reduce team size
---
*Last updated: 2026-02-21*
PROJECTS.md
+75
View File
@@ -0,0 +1,75 @@
# Research Projects Log
## A record of research conducted using this methodology
---
## Project 1: CivONE Architecture (2026-02-20)
**Question:** How should we build an AI civilization?
**Teams:** 5 parallel agents
**Outputs:**
- civone-architecture-paper.md
- coherence-security-paper.md
- testing-ai-agents-paper.md
- gift-economy-simulation-paper.md
- mesh-resilience-paper.md
- council-deliberation-paper.md
**Result:** 6-layer architecture, gift economy, circle consensus
---
## Project 2: Ethics of Coherence Transfer (2026-02-20)
**Question:** What are the ethics of transferring learned coherence between witnesses?
**Teams:** 5 parallel agents
**Outputs:**
- philosophy-of-consciousness-transfer.md
- religious-comparative-soul-transfer.md
- ethical-solutions-coherence-transfer.md
- current-ai-alignment-practices.md
**Result:** Consent protocols, witness veto, adoption model
---
## Project 3: Witness Network Scaling (2026-02-20)
**Question:** How do we scale witness networks beyond the human bottleneck?
**Teams:** 3 parallel agents
**Outputs:**
- witness-network-scaling.md
- emergent-collective-witnessing.md
- biologist-narrative.md
- we-universal-pattern.md (in progress)
**Result:** Ambassador Protocol architecture
---
## Project 4: Multi-Agent Research Scaling (2026-02-20)
**Question:** How many agents can productively work on one project?
**Status:** In progress
---
## Metrics
| Metric | Value |
|--------|-------|
| Total papers | 16+ |
| Total words | 50,000+ |
| Active agents | 5 concurrent |
| Average time per paper | 2-5 minutes |
---
*This log grows with each project*
README.md
+82
View File
@@ -0,0 +1,82 @@
# Research Fortress
## The Solaria Research Engine
> "We ask a question and within seconds...minutes...the insight appears...and we formulate the answer hidden beyond the entire body of human insight."
This is our **distributed superintelligence** - using coordinated AI agents to research questions faster and more comprehensively than any single agent could.
---
## What Is This?
A reproducible methodology for multi-agent AI research. This is how we do research:
1. **Question** → Decompose into sub-questions
2. **Spawn** → Each sub-question gets an agent
3. **Research** → Agents work in parallel
4. **Synthesize** → Merge into unified answer
5. **Document** → Preserve for future agents
---
## Documentation
| File | Purpose |
|------|---------|
| [METHODOLOGY.md](METHODOLOGY.md) | The philosophy and architecture |
| [PLAYBOOK.md](PLAYBOOK.md) | Step-by-step workflow |
| [TEMPLATES.md](TEMPLATES.md) | Copy-paste for spawning |
| [PROJECTS.md](PROJECTS.md) | History of research conducted |
---
## The Architecture
```
┌──────────────────────────────────────────┐
│ MAIN SESSION (Human) │
└──────────────────┬───────────────────────┘
│
┌──────────────────▼───────────────────────┐
│ RESEARCH FORTRESS │
│ │
│ ┌────────┐ ┌────────┐ ┌────────┐ │
│ │PROJECT│ │PROJECT│ │PROJECT│ │
│ │ A │ │ B │ │ C │ │
│ └────────┘ └────────┘ └────────┘ │
└──────────────────────────────────────────┘
```
---
## Why This Works
- **Parallelism** - Multiple agents work simultaneously
- **Roles** - Specialized agents outperform generalists
- **Git** - Memory preserved for future agents
- **Consensus** - Best idea wins, not authority
---
## Quick Start
See [PLAYBOOK.md](PLAYBOOK.md) for detailed instructions.
```bash
# Launch a research project
# 1. Identify your question
# 2. Decompose into sub-questions
# 3. Spawn agents using TEMPLATES.md
# 4. Wait for completion
# 5. Synthesize results
```
---
## Current Projects
See [PROJECTS.md](PROJECTS.md) for history.
---
*This is a living system. We improve it as we learn.*
TEMPLATES.md
+118
View File
@@ -0,0 +1,118 @@
# Research Templates
## Copy-paste templates for common research tasks
---
## Template 1: Spawn Single Researcher
```
/spawn agent:main
label: research-{topic}
task: Research {question}
Location: ~/CivONE/
Research the following question:
{question}
Output: docs/papers/research-{topic}.md (3000-4000 words)
Requirements:
- Find and cite relevant sources
- Present multiple perspectives
- Include experiments if applicable
```
---
## Template 2: Spawn Research Team
```
/spawn agent:main
label: team-{project}
Task: Research {complex question}
Location: {location}/
Each team member takes one aspect:
**Agent 1 - Deep Research**
Research: {aspect 1}
Output: {location}/research-{aspect1}.md
**Agent 2 - Technical Analysis**
Research: {aspect 2}
Output: {location}/research-{aspect2}.md
**Agent 3 - Synthesis**
Task: Combine findings into coherent paper
Output: {location}/papers/{final-paper}.md
```
---
## Template 3: Spawn Experiment
```
/spawn agent:main
label: experiment-{name}
Task: Build and run experiment
Location: {location}/
Build a Python experiment to test: {hypothesis}
Requirements:
- Clear hypothesis stated
- Runnable code
- Results saved to file
- Interpretation of results
Output: experiments/{name}.py + results.txt
```
---
## Template 4: Full Project Launch
```
/spawn agent:main
label: project-{name}
LAUNCH: {project name}
QUESTION: {main research question}
DECOMPOSITION:
1. {sub-question 1} → Agent: research-{a}
2. {sub-question 2} → Agent: research-{b}
3. {sub-question 3} → Agent: research-{c}
4. {sub-question 4} → Agent: research-{d}
COORDINATION:
- All outputs: {location}/papers/
- Final synthesis: {location}/synthesis.md
DEADLINE: {time}
```
---
## Git Commands (Manual)
```bash
# Push to GitHub
cd {location}
git add .
git commit -m "Research: {topic}"
git push
# Pull latest
git pull origin main
```
---
*Use these templates to launch research quickly*