🚧 Work in Progress (WIP)

⚔️ Strategy Council

AI-powered strategic advisory council — offline, private, multi-agent simulation

---

Strategy Council runs a structured war-game simulation entirely on your machine. You describe a scenario; a council of autonomous AI agents — each embodying a distinct strategic doctrine from history's greatest thinkers — debates it, challenges each other's positions, and produces synthesized recommendations.

Zero data leaves your machine. Ever.

Key Features

• 5 AI Strategist Advisors — Sun Tzu, Chanakya, Marcus Aurelius, Machiavelli, and Clausewitz, each reasoning from their embedded source texts
• Multi-Agent Debate Simulation — Structured multi-round deliberation powered by CAMEL-AI/OASIS multi-agent patterns
• 100% Offline — Zero Cloud Dependency — All LLM inference runs locally via Ollama on an internal Docker network
• Knowledge Graph Visualization — Interactive D3.js force-directed graph with Neo4j backend and visual diff after variable injection
• Red Team Agent — Devil's advocate that stress-tests the emerging consensus in final rounds
• Voice Interface — Offline Whisper STT + Coqui TTS with distinct voices per strategist
• Immutable Audit Trail — SHA-256 hash-chained session logs with PDF/JSON/Markdown export
• 8 Scenario Templates — Pre-built templates for common strategic challenges
• Tauri Native Desktop App — Lightweight native desktop shell with system tray integration

Quick Start

Prerequisites

• Docker Desktop (or Docker Engine + Docker Compose)
• 8 GB RAM minimum (16 GB+ recommended)

1. Clone & Install

git clone https://github.com/gtm-k/strategy-council.git
cd strategy-council

2. Configure Environment

# Copy environment configuration (first time only)
cp .env.example .env

Note: The installer scripts do this automatically. If running Docker Compose manually, copy .env first.

3. Launch

# macOS / Linux
chmod +x installer/install.sh
./installer/install.sh

# Windows (double-click or run from terminal)
installer\install.bat
# Or from PowerShell:
.\installer\install.ps1

Or manually with Docker Compose:

docker compose up -d --build

4. Open

Navigate to http://localhost:3000 — the Council is ready.

On first launch, Ollama will pull the LLM model automatically (this takes a few minutes depending on your hardware tier). Once loaded, create a new session, pick a scenario template or write your own, and start the deliberation.

Hardware Requirements

Tier	RAM	VRAM	Model	Speed
Laptop (CPU)	8–16 GB	None	Qwen3-7B-Q4	~8 tok/s
Laptop (GPU)	16 GB	8 GB	Qwen3-14B-Q5	~18 tok/s
Workstation	32 GB	16 GB	Qwen3-32B-Q4	~12 tok/s
Power Station	64 GB+	24 GB+	Llama3.1-70B-Q5	~10 tok/s

Hardware detection is automatic. Override in Settings or council_config.yaml if needed.

The Council

Strategist	Source Doctrine	Focus
Sun Tzu	Art of War	Information asymmetry, deception, force economy
Chanakya	Arthashastra	Statecraft, intelligence networks, escalation strategy
Marcus Aurelius	Meditations	Resilience, long-game ethics, adversity response
Machiavelli	The Prince	Realpolitik, power consolidation, coalition management
Clausewitz	On War	Center of gravity, fog of war, strategic friction

Architecture

┌─────────────────────────────────────────────────────────┐
│                    Tauri Desktop Shell                    │
│                  (Native Window + Menu)                   │
├─────────────────────────────────────────────────────────┤
│                                                          │
│   ┌──────────────┐    ┌──────────────┐    ┌──────────┐  │
│   │   Frontend    │    │   Backend    │    │  Ollama   │  │
│   │  Vue.js 3     │◄──►│  FastAPI     │◄──►│  Local    │  │
│   │  Tailwind CSS │    │  Python      │    │  LLM +    │  │
│   │  D3.js Graph  │    │              │    │  Embed    │  │
│   └──────┬───────┘    └──────┬───────┘    └──────────┘  │
│          │                    │                           │
│          │    WebSocket       │                           │
│          └────────────────────┤                           │
│                    ┌──────────┴──────────┐               │
│                    │                     │               │
│          ┌────────┴────────┐  ┌────────┴────────┐      │
│          │    SQLite DBs    │  │     Neo4j CE     │      │
│          │  Audit + Memory  │  │  Knowledge Graph │      │
│          │  (local fallback)│  │  + Vector Index  │      │
│          └─────────────────┘  └─────────────────┘      │
│                                                          │
│          Docker Compose (council_net bridge)              │
│          internal: true — zero cloud dependency          │
└─────────────────────────────────────────────────────────┘

Layer	Technology
Desktop Shell	Tauri 2.0 (Rust)
Frontend	Vue.js 3 + Vite + Tailwind CSS + D3.js
Backend	FastAPI (Python 3.11+)
LLM Inference	Ollama (local, OpenAI-compatible API)
Knowledge Graph	Neo4j Community Edition + APOC
Embeddings	nomic-embed-text (768-dim, via Ollama)
Audit Trail	SQLite + SHA-256 hash chain
Voice	Whisper (STT) + Coqui TTS
Orchestration	Docker Compose (internal bridge network)

Data Sovereignty

All services communicate over a Docker bridge network configured with internal: true. This means:

• No DNS resolution outside the container network
• No HTTP/HTTPS egress to the internet
• All LLM inference happens locally via Ollama
• Verified with tcpdump before each release — zero external packets

Scenario Templates

Template	Description
Competitive Entry	A funded competitor enters your core market — defend your position
Market Expansion	Evaluate entry into a new geography, vertical, or customer segment
Crisis Response	Manage an acute crisis threatening reputation, operations, or survival
M&A Defense	Respond to an unsolicited acquisition or hostile takeover bid
Product Launch	Plan the strategic launch of a major new product or platform
Coalition Building	Form alliances, partnerships, or industry coalitions for shared objectives
Regulatory Challenge	Navigate new regulations or compliance requirements impacting your business
Talent War	Compete for critical human capital in a tight labor market

Configuration

The main configuration file is council_config.yaml:

council:
  default_advisors: [sun_tzu, chanakya, marcus_aurelius, machiavelli, clausewitz]
  default_rounds: 8
  red_team: enabled

hardware:
  tier: workstation       # auto-detected
  model: qwen3-32b-q4    # auto-selected

voice:
  enabled: true
  activation: push_to_talk

See .env.example for all environment variables. Copy to .env and adjust for your setup.

Development

Backend

cd backend
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
uvicorn main:app --host 0.0.0.0 --port 5001 --reload

Frontend

cd frontend
npm install
npm run dev

Docker (Full Stack)

docker compose up -d --build

Running Tests

cd backend
python -m pytest tests/ -v

Adding a New Doctrine Pack

No code changes required — the system auto-discovers new personas:

1. Create a YAML persona file in backend/council/personas/
2. Create a doctrine pack directory in backend/council/doctrine_packs/
3. Add the source text as source.txt

API Reference

Method	Endpoint	Description
POST	/api/sessions	Create new council session
GET	/api/sessions	List all sessions
GET	/api/sessions/{id}	Get session details
POST	/api/sessions/{id}/start	Start deliberation
POST	/api/sessions/{id}/inject	Variable injection
GET	/api/sessions/{id}/report	Get council report
GET	/api/sessions/{id}/audit	Get audit trail
POST	/api/sessions/{id}/export	Export (PDF/JSON/MD)
GET	/api/personas	List strategists
GET	/api/templates	List scenario templates
GET	/api/config	Get configuration
PUT	/api/config	Update configuration
POST	/api/voice/stt	Speech to text
POST	/api/voice/tts	Text to speech
WS	/ws/sessions/{id}	Real-time simulation stream

Contributing

Contributions welcome! See CONTRIBUTING.md for development guidelines, code style, and pull request expectations.

Security

Strategy Council is designed as an offline-first application with zero external network dependencies. See SECURITY.md for our full security policy, data sovereignty guarantees, and vulnerability reporting process.

To report a vulnerability, email security@strategycouncil.dev or use GitHub's private security advisory feature.

License

This project is licensed under the GNU Affero General Public License v3.0.

Acknowledgments

• MiroFish-Offline by nikmcfly — Production utilities layer (LLM client, Neo4j storage, embeddings, NER, hybrid search, retry logic, file parser, D3.js graph visualization). Licensed under AGPL-3.0.
• MiroFish — Original social simulation engine
• CAMEL-AI — Multi-agent simulation patterns
• Ollama — Local LLM inference
• Neo4j Community Edition — Knowledge graph storage
• Tauri — Native desktop application framework
• Doctrine texts sourced from public domain translations