Cluster Online · Auto-Failover · 24/7 Autonomous

Two Machines.
One Autonomous Operation.

A dual Mac Mini cluster running 183+ AI skills, multi-model orchestration, autonomous software pipelines, financial analysis engines, and a self-healing infrastructure — replacing over $50,000/year in SaaS tools and human coordination.

0AI Skills
Code architecture, content generation, trading research, knowledge synthesis, automation, debugging — all loaded on-demand without pre-staging. Up from 141 with new cluster skills.
0Managed Services
27 services across 2 machines. Gateway, Ollama, PostgreSQL@17, workspace-sync, health-check-anvil, Redis, voice bot, finance stack, and more — all auto-restart with cross-machine failover.
0Knowledge Pages
Indexed across 6+ Obsidian vaults. 16,056 embedded chunks. PostgreSQL + pgvector on Anvil (primary), WAL-streamed to Forge (standby). Hybrid vector + full-text search.
0Embedded Chunks
16,056 semantic chunks via nomic-embed-text (768-dim). Jina v5 queued for migration. Auto re-embeds stale content. WAL-replicated hot standby on Forge.
0AI Models
5 cloud models + 7 local models across Forge (Ollama) and Anvil (Ollama). Routed by task type: GLM-5.1 default, GLM-5.2 code pipeline, diversity-enforced. Zero lock-in.
0Monthly Cost
$65 cloud AI + ~$12 electricity for 2 machines running 24/7. No developer salary. No SaaS tools. Replaces $22,000/month traditional IT setup.
2Machines
Forge (M4, 16GB) — gateway + routing + standby. Anvil (M4 Pro, 48GB) — compute + brain + primary. Thunderbolt 4 direct link at ~1–3ms latency. ~22W combined idle.
Explore the full stack
At a Glance

Live Cluster Profile

The numbers behind a two-machine system that thinks, codes, trades, researches, and manages itself.

🖥️2 MachinesForge + Anvil
Forge: M4 Mac Mini (16GB) — gateway, routing, embeddings, SECONDARY failover. ~15W idle. Anvil: M4 Pro Mac Mini (48GB) — LLM inference, PostgreSQL primary, builds. ~7W idle. Thunderbolt 4 direct link (10.0.0.1/30 ↔ 10.0.0.2/30), ~1–3ms latency. ~22W combined.
183Composable skills
Modular AI skills loaded on-demand — code architecture, content generation, trading research, browser automation, knowledge synthesis, debugging, deployment. Each skill carries its own playbook and tool permissions.
🧠16,056Embedded knowledge chunks
Semantic chunks indexed across 6+ Obsidian vaults via PostgreSQL 17 + pgvector on Anvil. Hybrid vector + full-text search using nomic-embed-text (768-dim). WAL-streamed hot standby on Forge. Jina v5 queued for migration.
⚙️27LaunchDaemon services
22 on Forge + 5 on Anvil. Core: OpenClaw Gateway, Ollama×2, PostgreSQL@17×2, pg-replication-tunnel, workspace-sync, health-check-anvil, thunderbolt-ip, Redis, Apex Voice Bot, git hooks, Paperclip. All auto-restart capable. Cross-machine failover if primary dies.
8Scheduled cron jobs
Weekly full backup, daily git backup, 2-min cross-machine health checks, 6-hour knowledge graph sync, weekly knowledge distiller, heartbeat pulses, session snapshots, and WAL cleanup.
📝171+Memory & log files
Three-tier memory: working (session context), daily logs (chronological events), and long-term curated knowledge. Plus entity state, active thread tracking, and cross-reference indices. Synced across both machines every 5 min.
📚6+Obsidian vaults
Organized by venture: Fulcrum AI (automation agency), Nexdex (trading research), Vibestreet (marketplace), Inclination (shopping assistant), Infrastructure, and Strategy. All indexed and searchable via Anvil primary DB.
🔬300+Trading research docs
Quantitative research across 64+ strategy documents. Models: Markov chain price prediction, Black-Scholes options pricing, Kelly Criterion sizing, Bayesian probability. Top edge: weather markets at 94% win rate.
🛡️4-LayerSecurity defense system
Pre-tool-use blocking (secrets, risky commands, SQL injection), post-tool observability logging, 18-pattern pre-commit secret scanner, and continuous health monitoring with auto-failover. Health checks every 2 minutes across both machines.
💰$70/moTotal operating cost
$65 cloud AI model costs + ~$12 electricity for 2 machines. Zero SaaS subscriptions, zero cloud infrastructure, zero developer salaries. Replaces a traditional IT setup costing $22,000+/month.
📈99%+Uptime (auto-failover)
Health check runs every 2 minutes. 3 consecutive failures → auto-failover switches GBRAIN_DATABASE_URL to Forge standby. If Anvil dies, Forge keeps running on standby DB. If Forge dies, Anvil has full workspace + compute. Alerts to Discord + WhatsApp.
🎬3Media generation engines
Image generation (OpenAI GPT-Image, Fal Flux, Google), video generation (text-to-video, image-to-video up to 4K), and music generation (Google Lyria, genre/mood/instrument control). Multi-provider routing.
Cluster Architecture

Forge + Anvil: The Dual-Machine Stack

Two specialized machines, directly linked via Thunderbolt 4, forming one coherent autonomous operation with hot standby and auto-failover.

Forge

Forge

Apple M4 · 16GB Unified Memory
RoleGateway + Routing + Standby
IP10.0.0.1/30
Idle power~15W
DBPostgreSQL@17 (standby)
Services22 LaunchDaemons
  • OpenClaw Gateway (all channel routing)
  • Ollama — nomic-embed-text, jina-v5
  • WAL streaming receiver (hot standby)
  • workspace-sync receiver (rsync, 5 min)
  • health-check-anvil (every 2 min)
  • Redis, Voice Bot, Git hooks
  • Failover: takes PRIMARY if Anvil dies
Anvil

Anvil

Apple M4 Pro · 48GB Unified Memory
RoleCompute + Brain + Primary
IP10.0.0.2/30
Idle power~7W
DBPostgreSQL@17 (primary)
Services5 LaunchDaemons
  • Heavy LLM inference (qwen3.6:35B, qwen3-coder:30B)
  • PostgreSQL@17 PRIMARY — gBrain DB
  • WAL streaming sender → Forge standby
  • Vision: qwen3-vl:8b (always-on)
  • nomic-embed-text + jina-v5 (embeddings)
  • Builds, code execution, simulations
  • OpenClaw client (receives delegated tasks)
Capability Stack

Nine Pillars of Autonomous Operations

Each pillar is a self-contained capability domain. Together, they form a system that operates, decides, and creates — independently.

🧠

Multi-Model AI Cognition

12 models · cloud + 2× local Ollama · intelligent routing
5 cloud models 7 local models ~$70/mo total spend Diversity-enforced routing

☁️ Cloud Models

Five cloud models routed by task type, enforcing GLM→Claude→GLM→Claude diversity.

  • GLM-5.1 PRIMARY — Default for ALL sessions, ALL channels. Everyday operations.
  • GLM-5.2 CODE PIPELINE — Architect + Reviewer roles only.
  • Claude Sonnet 4.6 CODER — General pipeline Coder role.
  • Fable 5 VIBESTREET — Vibestreet pipeline Coder role only.
  • Claude Haiku 4.5 COMPACTION — Context compaction, 30K token floor.

🖥️ Forge Local (Ollama) Forge

Lightweight local inference on Forge — always-on embeddings, on-demand testing.

  • qwen3.5:9B — General pipeline Tester role, on-demand
  • nomic-embed-text — gBrain embeddings, always-on
  • jina-embeddings-v5-text-small — Future embedding migration (dormant)

⚡ Anvil Local (Ollama) Anvil

Heavy LLM inference on Anvil's 48GB M4 Pro — daily tasks, vision, code generation.

  • qwen3.6:35B — Daily/swarm/simulation tasks
  • qwen3-coder:30B — Code generation
  • qwen3-vl:8b — Vision tasks, always-on
  • gemma3:12b — Media generation
  • nomic-embed-text + jina-v5 — Embedding (legacy + new)

🔀 Model Routing Rules

  • GLM-5.1 default everywhere — all sessions, all channels
  • GLM-5.2 code pipeline only (Architect + Reviewer)
  • Diversity enforcement: GLM→Claude→GLM→Claude rotation
  • Local LLMs NEVER used for trading, math, or knowledge-critical tasks
  • Ollama Anvil models delegated via Forge → Anvil routing
💻

Autonomous Software Engineering

2 pipelines · 8-stage process · $0.24–$0.95/run
2 specialist pipelines 8-stage process ~$0.24–$0.95 per run Model diversity enforced

🔧 Code Pipelines

Two specialist pipelines — each uses different models tuned for the target project:

Vibestreet Pipeline ~$0.95/run
AArchitect (GLM-5.2)
Breaks down Vibestreet requirements into tech specs, architecture, and implementation roadmap. Outputs design docs and module breakdown.
CCoder (Fable 5)
Fable 5 writes Vibestreet-specific production code. Marketplace patterns, UI-first, mobile-ready. Output goes to Reviewer gate.
RReviewer (GLM-5.2)
Quality gate. Reviews against Vibestreet spec. Can reject with feedback → loops back to Coder (max 3 iterations).
TTester (Haiku 4.5)
Runs test suites. All tests must pass green. Verifies coverage ≥80%. Ship-ready on approval.
General Pipeline ~$0.24/run
AArchitect (GLM-5.2)
System design, tech specs, module breakdown for general projects. Outputs architecture doc for Coder to follow precisely.
CCoder (Sonnet 4.6)
Claude Sonnet 4.6 writes production-quality code. Handles implementation, testing utilities, and edge cases. Goes to Reviewer gate.
RReviewer (GLM-5.2)
Spec-aligned review. Can reject with feedback → loops back (max 3 iterations). Only passes complete, documented, spec-aligned code.
TTester (Ollama qwen3.5)
Local Ollama qwen3.5 on Forge runs test suites — zero extra API cost. Unit, integration, e2e. Coverage ≥80% required.

🏗️ 8-Stage Development Process

End-to-end workflow from idea to deployed feature:

  • 1. GrillMe — Requirements validation, edge case stress-test
  • 2. Requirements + Paperclip — Spec written, issue created with Done-When criteria
  • 3. Architecture — Design review, tech decision, module map
  • 4. Code Pipeline — 4-stage specialist execution (above)
  • 5. Review Gate — CEO/Engineering/Design review sign-off
  • 6. Testing — Unit + integration coverage verification
  • 7. Integration Testing — End-to-end system validation
  • 8. Deployment — Canary deploy, land-and-verify, monitoring

🏗️ Sprint Lifecycle (gstack)

Composable engineering sub-skills loaded on demand:

  • Spec-driven development & incremental implementation
  • Design review, engineering review, CEO review gates
  • QA automation, security audit, SQL safety checks
  • Canary deployment monitoring & land-and-deploy strategies
  • Engineering retrospectives with commit analysis
  • Spike/prototyping validation framework

🐛 Debugging & Diagnostics

  • Node.js inspector debugger integration
  • Python debugpy live debugging
  • Session log analysis & error classification
  • Automated timeout, rate-limit, and auth error detection

📦 Project Management Integration

  • Paperclip issue tracking (create → assign → execute → ship)
  • GitHub issue sync with messaging channels
  • Automated "Done When" criteria verification
  • Multi-company portfolio management
📊

Financial Analysis & Trading

7 modules · SEC EDGAR · quant models
7 finance modules 300+ research docs 4 quant models SEC EDGAR integrated

📋 Financial Statements Engine

Full SEC filing extraction and 3-statement modeling.

  • 10-K, 10-Q, 8-K parsing from SEC EDGAR
  • 3-statement Excel models (Base / Upside / Downside)
  • Historical financial data via yfinance API
  • Automated ratio analysis & trend detection

🎯 Earnings & Valuation

  • Earnings analysis with bullish/bearish signal scoring
  • DCF, comparables, and peer benchmarking
  • Investment pitch one-pagers with target prices
  • Peer comparison engine (MAG7, SEMIS, Cloud, Banks)

📈 Nexdex Trading Intelligence

Quantitative trading research and model development.

  • Markov chain price prediction
  • Black-Scholes options pricing
  • Kelly Criterion position sizing
  • Bayesian probability modeling
  • Top edges: weather markets (94% WR), stat arb, oracle latency arb
  • 300+ research files across 64+ strategy documents

🔍 Sector & Market Research

  • Industry competitive analysis & due diligence
  • Target screening & acquisition pipeline
  • Real-time price data feeds
  • Python finance stack: pandas, numpy, openpyxl, xlsxwriter
🧠

Knowledge & Memory Architecture

2,652 pages · 16,056 chunks · PostgreSQL + pgvector
2,652 knowledge pages 16,056 embedded chunks 6+ Obsidian vaults 171+ memory files

🔗 gBrain Knowledge Graph Anvil Primary

Semantic knowledge engine — PostgreSQL 17 + pgvector on Anvil, WAL-streamed to Forge standby.

  • 2,652 pages indexed across 6+ vaults
  • 16,056 embedded chunks (nomic-embed-text, 768-dim)
  • PostgreSQL 17 + pgvector — hybrid vector + full-text search
  • Jina-embeddings-v5-text-small queued for migration
  • WAL streaming to Forge — hot standby always in sync
  • Auto-re-embeds stale content on every import

📓 Document Knowledge Base

6 Obsidian vaults organized by venture and domain:

  • Fulcrum AI — automation agency docs
  • Nexdex — trading research & models
  • Vibestreet — marketplace architecture
  • Inclination — AI shopping assistant
  • Infrastructure — system docs
  • Strategy — business strategy & planning

💾 Three-Tier Memory System

Different persistence guarantees for different needs:

  • Working: Current session context (60K token window)
  • Daily logs: Raw chronological events, append-only
  • Long-term: Curated, deduplicated permanent knowledge

🔄 State Persistence Layer (CPL)

Bridges session memory and permanent storage — no context lost across restarts.

  • Living entity ontology (people, companies, projects)
  • Active thread tracker (WIP tasks & decisions)
  • Bidirectional cross-reference index
  • Pre-compaction session snapshots
  • rsync'd to Anvil every 5 min — both machines always current
🎨

Creative & Media Generation

3 engines · image · video · music
3 media engines Multi-provider routing Up to 4K resolution 20 images per analysis

🖼️ Image Generation

Multi-provider routing to OpenAI GPT-Image, Fal.ai Flux, Google, and more.

  • Transparent backgrounds (PNG/WebP)
  • 1-4 images per call, aspect ratios 1:1 through 8:1
  • Reference images for style transfer & editing (up to 10)
  • Resolutions up to 4K, quality control (low/medium/high)
  • Provider-specific: OpenAI moderation, Fal creativity levels

🎬 Video Generation

Text-to-video, image-to-video, and video-to-video with multi-modal references.

  • First frame, last frame, and reference image support
  • Up to 9 reference images, 4 reference videos, 3 audio refs
  • Aspect ratios: 1:1, 16:9, 9:16, adaptive
  • Resolutions: 360P through 4K
  • Audio-conditioned generation (reference music/audio)
  • Provider options: seeds, watermark control, duration

🎵 Music Generation

Multi-provider audio creation including Google Lyria.

  • Genre, mood, tempo, instrument, purpose prompts
  • Sung lyrics support or instrumental-only mode
  • Reference images for visual mood injection
  • MP3/WAV output, configurable duration

👁️ Vision & Image Analysis Anvil

Configured vision model for inspection and understanding — qwen3-vl:8b always-on on Anvil.

  • Up to 20 images per analysis call
  • Custom inspection prompts
  • 20MB max per image
  • Cross-modal review capabilities
🛡️

Security & Defense Systems

4-layer defense · 2-min health checks · auto-failover
4-layer defense 2-min health checks Auto-failover after 3 failures Thermal protection

🔒 Pre-Tool-Use Defense Layer

Blocks dangerous operations before they execute.

  • Secret detection: Anthropic keys (sk-ant-), OpenAI keys (sk-), AWS keys (AKIA), JWT tokens, GitHub tokens (ghp_), Discord tokens
  • Risky command blocking: rm -rf /, rm -rf ~, > /dev/sda, dd if=/dev/zero, chmod -R 777 /, curl|bash, wget|bash
  • SQL injection prevention: DROP TABLE, DROP DATABASE, DELETE FROM...WHERE 1
  • Returns block decision JSON — execution never starts

📊 Post-Tool-Use Observability

Full audit trail after every tool execution.

  • JSONL logging to tool-usage.jsonl
  • Latency tracking (start/end timestamps → ms)
  • Error classification: timeout, rate_limit, connection, permission, not_found, auth
  • Auto-format Python files after writes
  • Post-execution secret scanning

🔍 Pre-Commit Secret Scanner

18-pattern scanner prevents secrets from entering version control.

  • API key patterns for all major providers
  • Private key detection (RSA, EC, PGP)
  • Database connection string detection
  • Generic high-entropy string detection

🌡️ Cross-Machine Health & Auto-Failover

Continuous monitoring with automatic failover — not just restart.

  • Health check runs every 2 minutes (was 15)
  • Forge monitors Anvil — 3 consecutive failures → auto-failover
  • GBRAIN_DATABASE_URL switches to localhost standby on Forge
  • CPU thermal monitoring & throttling defense on both machines
  • Alerts to Discord + WhatsApp on failover events
  • If Anvil dies → Forge keeps full operations on standby DB
  • If Forge dies → Anvil has full workspace + compute, self-sufficient
📡

Communication & Human Interface

Multi-channel · voice · co-worker access
3+ comms channels Voice wake word Scoped co-worker access Platform-aware formatting

💬 Discord Multi-Channel Hub

Venture-scoped channels for focused operational context.

  • Dedicated channels: Infrastructure, Strategy, Brand, Trading, Agency, Marketplace
  • Real-time agent monitoring & session management
  • Project management bridge — issue status syncs to chat
  • Thread-bound sub-agent spawning for parallel work
  • Rich components: buttons, selects, forms, polls, reactions

📱 WhatsApp Direct Line

Time-sensitive alerts and briefings to leadership.

  • Heartbeat alerts for urgent items
  • Quiet hours enforcement (23:00–08:00)
  • Platform-aware formatting (no markdown tables)
  • Daily briefing delivery + failover event alerts

🌐 Web Control Panel

Browser-based administration and monitoring.

  • Session listing & history inspection
  • Agent configuration & model overrides
  • Tool testing & approval management
  • Gateway status & health monitoring for both machines
  • Scheduled job management

🎙️ Voice Interface

Wake-word activated voice assistant.

  • Wake word: "Apex" — hands-free interaction
  • Text-to-speech output (voice selection configurable)
  • Seamless integration with all agent capabilities

👥 Co-Worker Access System

Scoped permissions for team collaboration.

  • Brenda — sandboxed workspace, image generation access, strict permission model
  • Alizain — full technical CRUD, deploy/config changes require Chairman approval
  • Role-based access control with workspace isolation
⚙️

Automation & Operations

8 cron jobs · 27 services · browser automation
27 managed services 8 scheduled jobs Stealth browser 3-gen backups

⏰ Scheduled Task Engine

Cron-driven automation for self-maintaining operations.

  • System backup: weekly full backup to external drive
  • Git backup: daily version-controlled state backup
  • Health check: every 2 minutes — cross-machine verification
  • Knowledge distiller: weekly structural analysis
  • Knowledge graph sync: every 6 hours — re-imports & re-embeds
  • Workspace sync: every 5 minutes — rsync Forge ↔ Anvil
  • WAL cleanup: periodic maintenance on Anvil
  • Context snapshots: as needed before compaction

🦊 Stealth Browser Automation

Anti-detection web automation with full session control.

  • Anti-fingerprint patches — interacts as a real user
  • Cookie injection for authenticated sessions
  • Screenshot capture, DOM interaction, form filling
  • Use cases: job scraping, social media posting, competitive research
  • Bypasses API limits by operating through the browser

📎 Background Agent

Dedicated agent for project management and issue processing.

  • Issue status synchronization
  • Priority-based sorting & automated triage
  • Runs on local model — zero incremental cost
  • Offloads routine management from primary agent

💾 Backup & Recovery System

3-generation rolling backup with multiple storage tiers.

  • Weekly full system backup to external drive
  • Daily git version-controlled state backup
  • 3-generation rolling rotation for disaster recovery
  • Pre-compaction session snapshots
  • Continuous rsync cross-machine workspace mirror
🔩

Infrastructure Core

2× Apple Silicon · Thunderbolt 4 · WAL replication
2× Apple Silicon Thunderbolt 4 direct link WAL replication ~22W combined idle

🍎 Hardware Platform

Two Apple Silicon Mac Minis — energy-efficient, silent, neural engine on-chip.

  • Forge: Apple M4 (16GB) — gateway, routing, embeddings. ~15W idle.
  • Anvil: Apple M4 Pro (48GB) — LLM compute, brain, builds. ~7W idle.
  • Thunderbolt 4 direct link: 10.0.0.1/30 ↔ 10.0.0.2/30, ~1–3ms latency
  • ~22W combined idle — both machines run 24/7 cost-effectively
  • No moving parts beyond fans — near-zero failure rate per machine

🏠 Local-First Architecture

Core operations have zero external dependencies.

  • Gateway binds to loopback only (127.0.0.1) on Forge
  • All AI inference can run on-device (Ollama on both machines)
  • Knowledge graph runs locally (PostgreSQL@17 + pgvector on Anvil)
  • Hot standby on Forge — database survives Anvil failure
  • External APIs only for premium cloud models & web research

🔌 Service Stack — Forge (22 services)

22 LaunchDaemons on Forge — all auto-restart capable.

  • OpenClaw Gateway — agent orchestration, all channel routing
  • Ollama — local LLM inference (nomic-embed-text, jina-v5, qwen3.5)
  • PostgreSQL@17 (standby) — WAL receiver from Anvil
  • pg-replication-tunnel — SSH tunnel for WAL (macOS bridge0 workaround)
  • workspace-sync — rsync to Anvil every 5 min
  • health-check-anvil — heartbeat every 2 min, auto-failover on 3× failure
  • thunderbolt-ip, thunderbolt-monitor — direct link management
  • Redis, Apex Voice Bot, Finance Python env, git hooks, Paperclip

🔌 Service Stack — Anvil (5 services)

5 LaunchDaemons on Anvil — compute-focused, self-contained.

  • Ollama — heavy LLM inference (qwen3.6:35B, qwen3-coder:30B, vision)
  • PostgreSQL@17 (primary) — gBrain database, WAL sender to Forge
  • thunderbolt-ip — direct link IP management
  • wal-cleanup — periodic WAL maintenance
  • OpenClaw client — receives delegated tasks from Forge gateway

🏗️ emergE Compute Framework

25-layer architecture specification for edge AI compute nodes.

  • Multi-tier hardware support: Hub Node → Standard → Lite → Edge → Micro
  • 3 open protocols: NATS (event bus), MCP (context), LDPM (device management)
  • 5 intelligence pillars: Core Runtime, Deployment, Intelligence, Security, Operations
  • Designed for multi-node federation — Apex Cluster is a live reference deployment
The Real Comparison

Traditional IT Stack vs. Apex Cluster

What it actually replaces — in hard numbers.

🏢 Traditional Setup

  • Developer(s) $120K+/yr
  • Financial analyst $80K+/yr
  • SaaS subscriptions $1,200/mo
  • Cloud infrastructure $500/mo
  • Project management tools $200/mo
  • Research & analysis tools $300/mo
  • Content creation tools $250/mo
  • Backup & monitoring $150/mo

⚡ Apex Cluster

  • Hardware (one-time, 2 Mac Minis) $1,600
  • AI model costs $65/mo
  • Electricity (2 machines, 24/7) $12/mo
  • SaaS subscriptions $0
  • Cloud infrastructure $0
  • Developer time $0
  • Analyst time $0
  • Content creation $0
Annual savings: $250,000+
Operating Economics

Where the Money Goes

Total monthly operating cost for the entire dual-machine cluster — less than a single SaaS subscription.

Traditional IT salary + SaaS
Baseline
$22,000/mo
Apex Cluster total
$70/mo
├ AI models (cloud)
$65
$65/mo
├ Local inference
$0
$0/mo
└ Electricity (2 machines, 24/7)
$12
$12/mo
In Practice

A Day in the Life

How a single request flows through the two-machine cluster — end to end, autonomously.

1

Request Received Forge

Chairman sends a message via Discord, WhatsApp, or voice. Forge Gateway receives it and routes to the primary AI model with full context loaded — memory, entity state, active threads. Forge handles all inbound channel routing.

2

Skill Resolution & Planning Forge

Agent scans 183 skills. If one matches, it loads automatically. If the task is complex, a goal is created and a multi-step plan is generated. Sub-agents may be spawned for parallel work. Light tasks stay on Forge; heavy compute is delegated to Anvil.

3

Execution Forge Anvil

Light tasks (routing, API calls, web research, file ops) execute on Forge. Heavy tasks (LLM inference, code builds, simulations) are delegated to Anvil via Thunderbolt 4. The security layer checks every tool call pre-execution and logs every result post-execution on both machines.

4

Knowledge Capture Anvil Primary

Every decision, output, and insight is captured. Memory files written on Forge are rsync'd to Anvil every 5 minutes. Knowledge graph updates go to Anvil's PostgreSQL primary and WAL-stream to Forge standby. State persistence layer tracks all entity changes across both machines.

5

Delivery & Monitoring Forge

Response delivered via originating channel with platform-appropriate formatting. Background monitoring continues — health checks every 2 minutes across both machines, backups on schedule, auto-failover if Anvil goes down, auto-recovery if any service crashes. The cluster never sleeps.