AGI Feeder

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 Node.js 20+ TypeScript License: MIT

---

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

# 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

# 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

# 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

# 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

# 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

# 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

# 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

# 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

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

# Via CLI
agi-feeder serve

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

Claude Desktop Integration

Add to your claude_desktop_config.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

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

# 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

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

---

Development

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