# Billionaire Mindset AGI Feeder v24.2026

> An AGI-style task orchestrator that routes tasks to the best AI models, aggregates results with confidence scoring, and applies billionaire thinking frameworks.

[![npm version](https://badge.fury.io/js/billionaire-mindset-agi-feeder.svg)](https://www.npmjs.com/package/billionaire-mindset-agi-feeder)
[![Node.js 20+](https://img.shields.io/badge/node-20+-brightgreen)](https://nodejs.org)
[![TypeScript](https://img.shields.io/badge/TypeScript-5.5-blue)](https://www.typescriptlang.org)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

---

## What It Does

**AGI Feeder** is a dual-mode tool: a **Model Context Protocol (MCP) server** and a **CLI** that acts as an intelligent AI task orchestrator:

- **Smart routing** — analyzes your task and sends it to the best model (GPT-4o, Claude 3.5, Gemini, DeepSeek R1, etc.)
- **Multi-model consensus** — queries multiple models and synthesizes their responses with confidence scoring
- **Deep chain-of-thought** — 3-stage reasoning: Model A reasons → Model B critiques → Model C synthesizes
- **Strategic decisions** — applies the full Billionaire Mindset framework (First Principles, Risk/Reward, 10x Filter, Anti-fragile)
- **Billionaire thinking frameworks** — 8 frameworks including Pareto 80/20, Asymmetric Risk, Network Effects
- **Batch orchestration** — process arrays of tasks in parallel across models

---

## Supported AI Models

| Provider | Models |
|----------|--------|
| **OpenAI** | GPT-4o, GPT-4o Mini, o1, o3-mini |
| **Anthropic** | Claude 3.5 Sonnet, Claude 3.5 Haiku, Claude 3 Opus |
| **Google** | Gemini 2.0 Flash, Gemini 1.5 Pro |
| **Mistral** | Mistral Large |
| **DeepSeek** | DeepSeek R1, DeepSeek V3 |

All providers are optional — the tool works with any subset of configured API keys.

---

## Installation

```bash
# NPM global install
npm install -g billionaire-mindset-agi-feeder

# Or use with npx
npx billionaire-mindset-agi-feeder <command>

# Or clone and build locally
git clone https://github.com/billionaire-mindset/agi-feeder
cd agi-feeder
npm install && npm run build
```

---

## Quick Start

### 1. Configure API Keys

```bash
# Interactive setup
agi-feeder config

# Or set environment variables
export OPENAI_API_KEY=sk-proj-...
export ANTHROPIC_API_KEY=sk-ant-...
export GOOGLE_API_KEY=AIza...

# Or copy .env.example to .env and fill in
cp .env.example .env
```

### 2. Route a Task

```bash
# Auto-detect task type and route to best model
agi-feeder route "Write a Python function to parse JWT tokens"

# With explicit task type
agi-feeder route "Explain quantum entanglement" --type reasoning

# With specific model
agi-feeder route "Debug this code" --model claude-3-5-sonnet-20241022
```

### 3. Multi-Model Consensus

```bash
# Query all configured models, get synthesized answer
agi-feeder consensus "What's the best way to scale a SaaS to $10M ARR?"

# Use specific models
agi-feeder consensus "Rate this business idea" --models gpt-4o,claude-3-5-sonnet-20241022
```

### 4. Deep Chain-of-Thought

```bash
# 3-stage reasoning: Reason → Critique → Synthesize
agi-feeder deep "Should I build a B2B or B2C startup?"

# Show full reasoning chain
agi-feeder deep "Solve the trolley problem" --show-chain
```

### 5. Strategic Decision

```bash
# Full billionaire mindset decision analysis
agi-feeder decide "Should I quit my job to start a startup?"
agi-feeder decide "Should we expand into the European market?"
```

### 6. Apply Mindset Frameworks

```bash
# List all frameworks
agi-feeder mindset list

# First Principles analysis
agi-feeder mindset first-principles "Why is my startup not growing?"

# Pareto 80/20
agi-feeder mindset pareto-8020 "How should I allocate my time as a founder?"

# Asymmetric Risk
agi-feeder mindset asymmetric-risk "Should I invest $50k in this opportunity?"

# 10x Moonshot
agi-feeder mindset 10x-moonshot "How do I 10x my consulting revenue?"

# Anti-fragile Strategy
agi-feeder mindset anti-fragile "How do I make my startup resilient to market crashes?"

# Infinite Leverage
agi-feeder mindset infinite-leverage "What's the highest ROI way to grow my audience?"

# Time Billionaire
agi-feeder mindset time-billionaire "Should I hire a VA or do these tasks myself?"

# Network Effects
agi-feeder mindset network-effects "How do I build a marketplace with strong network effects?"
```

### 7. Batch Processing

```bash
# Create a batch file
cat > tasks.json << 'EOF'
{
  "tasks": [
    { "id": "1", "task": "Summarize quantum computing in 3 sentences", "type": "analysis" },
    { "id": "2", "task": "Write a Python hello world", "type": "coding" },
    { "id": "3", "task": "Name 5 ways to generate passive income", "type": "creative" }
  ]
}
EOF

agi-feeder batch tasks.json

# Or use the example file
agi-feeder batch examples/batch-tasks.json
```

### 8. Check Model Status

```bash
agi-feeder status
agi-feeder status --provider openai
```

---

## MCP Server

AGI Feeder runs as a **Model Context Protocol server**, allowing AI assistants (Claude Desktop, Cursor, etc.) to use it as a tool.

### Start the Server

```bash
# Via CLI
agi-feeder serve

# Or directly
node bin/agi-feeder.js serve
```

### Claude Desktop Integration

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "agi-feeder": {
      "command": "node",
      "args": ["/path/to/agi-feeder/bin/agi-feeder.js", "serve"],
      "env": {
        "OPENAI_API_KEY": "sk-...",
        "ANTHROPIC_API_KEY": "sk-ant-...",
        "GOOGLE_API_KEY": "AIza..."
      }
    }
  }
}
```

### Available MCP Tools

| Tool | Description |
|------|-------------|
| `route_task` | Route task to best model with auto type detection |
| `multi_model_consensus` | Multi-model consensus with confidence scoring |
| `chain_of_thought_deep` | 3-stage deep reasoning chain |
| `strategic_decision` | Billionaire mindset decision framework |
| `batch_orchestrate` | Parallel batch task processing |
| `model_status` | Check model availability and API key status |
| `mindset_framework` | Apply any of 8 billionaire thinking frameworks |

---

## Billionaire Mindset Frameworks

| Framework | Tagline |
|-----------|---------|
| `first-principles` | Decompose to bedrock truth, rebuild from scratch |
| `pareto-8020` | 20% inputs drive 80% of outputs |
| `asymmetric-risk` | Limited downside, 100x upside bets |
| `10x-moonshot` | 10x is easier than 2x — abandon incrementalism |
| `anti-fragile` | Systems that get stronger from stress |
| `infinite-leverage` | Code, media, capital — zero marginal cost leverage |
| `time-billionaire` | Evaluate by time-freedom generated |
| `network-effects` | Score by flywheel and network potential |

---

## Programmatic API

```typescript
import {
  routeTask,
  multiModelConsensus,
  chainOfThoughtDeep,
  applyMindsetFramework,
  strategicDecision,
} from 'billionaire-mindset-agi-feeder';

// Route a task
const result = await routeTask({
  task: 'Build a REST API in Node.js',
  taskType: 'coding',
  maxTokens: 2048,
});

console.log(result.selectedModel); // e.g. "claude-3-5-sonnet-20241022"
console.log(result.result.response);

// Multi-model consensus
const consensus = await multiModelConsensus({ task: 'What is the future of AI?' });
console.log(consensus.aggregated.synthesis);
console.log(`Agreement: ${consensus.aggregated.agreement * 100}%`);

// Deep chain of thought
const deep = await chainOfThoughtDeep({ task: 'Is consciousness emergent?' });
console.log(deep.finalSynthesis);

// Apply a mindset framework
const mindset = await applyMindsetFramework('first-principles', 'Why is user acquisition expensive?');
console.log(mindset.insights);
mindset.actionItems.forEach((a) => console.log(`${a.action} (${a.impact})`));

// Strategic decision
const decision = await strategicDecision('Should I raise VC funding?');
console.log(decision.analysis.recommendation);
```

---

## Configuration

### Environment Variables

| Variable | Default | Description |
|----------|---------|-------------|
| `OPENAI_API_KEY` | — | OpenAI API key |
| `ANTHROPIC_API_KEY` | — | Anthropic API key |
| `GOOGLE_API_KEY` | — | Google/Gemini API key |
| `MISTRAL_API_KEY` | — | Mistral API key |
| `DEEPSEEK_API_KEY` | — | DeepSeek API key |
| `AGI_DEFAULT_MODEL` | `auto` | Default model (or "auto" for routing) |
| `AGI_OUTPUT_FORMAT` | `text` | Output format: text/json/markdown |
| `AGI_MAX_RETRIES` | `3` | Max API retry attempts |
| `AGI_TIMEOUT_MS` | `60000` | Request timeout (ms) |
| `AGI_LOG_LEVEL` | `info` | Log level: debug/info/warn/error |

### Config File

Saved to `~/.agi-feeder/config.json`. Managed via `agi-feeder config`.

---

## Docker

```bash
# Build and run
docker build -t agi-feeder .
docker run -e OPENAI_API_KEY=sk-... -e ANTHROPIC_API_KEY=sk-ant-... agi-feeder

# Docker Compose
cp .env.example .env  # fill in your keys
docker-compose up

# CLI via Docker
docker run --rm -e OPENAI_API_KEY=sk-... agi-feeder \
  node bin/agi-feeder.js route "Write a Fibonacci function in Rust"
```

---

## Railway Deployment

```bash
railway login
railway new
railway up
railway variables set OPENAI_API_KEY=sk-... ANTHROPIC_API_KEY=sk-ant-...
```

---

## Development

```bash
git clone https://github.com/billionaire-mindset/agi-feeder
cd agi-feeder
npm install
npm run build

# Run CLI without building (requires ts-node)
npm install ts-node --save-dev
npx ts-node src/cli/index.ts status

# Watch mode
npm run build:watch
```

---

## Architecture

```
src/
├── types/         — TypeScript type definitions
├── core/
│   ├── config.ts  — Configuration management
│   ├── models.ts  — Model registry + API calls (OpenAI, Anthropic, Google, Mistral, DeepSeek)
│   ├── router.ts  — Intelligent task router with type detection
│   ├── aggregator.ts — Multi-model consensus + chain-of-thought + batch
│   └── mindset.ts — 8 billionaire thinking frameworks engine
├── mcp-server/
│   ├── tools.ts   — MCP tool definitions and handlers
│   └── index.ts   — MCP server (stdio transport)
└── cli/
    ├── index.ts   — Commander.js CLI commands
    └── interactive.ts — Inquirer.js interactive prompts + formatters
```

---

## License

MIT — Built by [Billionaire Mindset AGI](https://github.com/billionaire-mindset)