a63e8505fa
Frontend (items 1-10):
- WebSocket streaming integration with useWebSocket hook
- Admin Dashboard UI (status, voices, agents, governance tabs)
- Voice playback UI (TTS/STT integration)
- Settings/Preferences page (conversation style, sliders)
- Responsive/mobile layout (breakpoints at 480px, 768px)
- Dark/light theme with CSS variables and localStorage
- Error handling & loading states (retry, empty state, disabled input)
- Authentication UI (login page, Bearer token, logout)
- Head visualization improvements (active/speaking states, animations)
- Consequence/Ethics dashboard (lessons, consequences, insights tabs)
Backend stubs (items 11-21):
- Tool connectors: DocsConnector (text/md/PDF), DBConnector (SQLite/Postgres), CodeRunnerConnector (Python/JS/Bash/Ruby sandboxed)
- STT adapter: WhisperSTTAdapter, AzureSTTAdapter
- Multi-modal interface adapters: Visual, Haptic, Gesture, Biometric
- SSE streaming endpoint (/v1/sessions/{id}/stream/sse)
- Multi-tenant support (X-Tenant-ID header, tenant CRUD)
- Plugin marketplace/registry (register, install, list)
- Backup/restore endpoints
- Versioned API negotiation (Accept-Version header, deprecation)
Infrastructure (items 22-26):
- docker-compose.yml (API + Postgres + Redis + frontend)
- .env.example with all configurable vars
- gunicorn.conf.py production ASGI config
- Prometheus metrics collector and /metrics endpoint
- Structured JSON logging configuration
Documentation (items 27-29):
- Architecture docs with module layout and subsystem descriptions
- Quickstart guide with setup, API tour, and test instructions
Tests (items 30-32):
- Integration tests: 25 end-to-end API tests
- Frontend tests: 10 Vitest tests for hooks (useTheme, useAuth)
- Load/performance tests: latency and throughput benchmarks
- Connector tests: 16 tests for Docs, DB, CodeRunner
- Multi-modal adapter tests: 9 tests
- Metrics collector tests: 5 tests
- STT adapter tests: 2 tests
511 Python tests passing, 10 frontend tests passing, 0 ruff errors.
Co-Authored-By: Nakamoto, S <defi@defi-oracle.io>
4.8 KiB
FusionAGI Architecture
Overview
FusionAGI is a modular AGI orchestration framework built on the Dvādaśa (12-headed) architecture. Multiple specialized reasoning heads analyze each prompt independently, and a Witness agent synthesizes their outputs into a consensus response.
Core Architecture
User Prompt
│
▼
┌─────────────────────────────────────────┐
│ Orchestrator (core/) │
│ Decompose → Fan-out → Synthesize │
├─────────────────────────────────────────┤
│ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │
│ │Logic│ │Creat│ │Resrch│ │Safety│ ... │
│ │Head │ │Head │ │Head │ │Head │ │
│ └──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘ │
│ └───────┴───────┴───────┘ │
│ Witness Agent │
│ (consensus synthesis) │
└──────────────┬──────────────────────────┘
│
┌──────────┼──────────┐
▼ ▼ ▼
┌────────┐ ┌────────┐ ┌────────┐
│Advisory│ │Conseq. │ │Adaptive│
│Governce│ │Engine │ │Ethics │
└────────┘ └────────┘ └────────┘
Module Layout
| Module | Responsibility |
|---|---|
core/ |
Orchestrator, event bus, state manager, persistence |
agents/ |
HeadAgent, WitnessAgent, Planner, Critic, Reasoner |
adapters/ |
LLM providers (OpenAI, TTS, STT), caching |
schemas/ |
Pydantic models — Task, Message, Plan, etc. |
tools/ |
Built-in tools (file, HTTP, shell) + connectors (docs, DB, code runner) |
memory/ |
InMemory and Postgres backends |
governance/ |
SafetyPipeline, PolicyEngine, AdaptiveEthics, ConsequenceEngine |
reasoning/ |
NativeReasoning, Metacognition, Interpretability |
world_model/ |
CausalWorldModel with self-modification prediction |
verification/ |
ClaimVerifier for output validation |
interfaces/ |
Multi-modal adapters (visual, haptic, gesture, biometric) |
maa/ |
Manufacturing Assurance Authority (geometry, physics, embodiment) |
api/ |
FastAPI app, routes, middleware, metrics |
Key Subsystems
Consequence Engine (governance/consequence_engine.py)
Every decision is a choice with alternatives, risk/reward estimates, and actual outcomes. The system learns from surprise (difference between predicted and actual outcomes).
Adaptive Ethics (governance/adaptive_ethics.py)
Consequentialist ethical framework that learns from experience rather than static rules. Lessons evolve weights based on observed outcomes. Advisory mode — observations, not enforcement.
Causal World Model (world_model/causal.py)
Predicts action→effect relationships from execution history. Includes self-modification prediction — the system models how its own capabilities change from self-improvement actions.
InsightBus (governance/insight_bus.py)
Cross-head shared learning channel. Heads contribute observations that other heads can learn from, enabling collaborative intelligence.
PersistentLearningStore (governance/persistent_store.py)
File-backed persistence for consequence data, ethical lessons, and risk histories across restarts.
Metacognition (reasoning/metacognition.py)
Self-awareness of knowledge boundaries. Evaluates reasoning quality, evidence sufficiency, and recommends when to seek more information.
Plugin System (agents/head_registry.py)
Extensible head registry with decorator-based registration. Custom heads can contribute to ethics and consequences via hooks.
API Architecture
- FastAPI with async support and lifespan management
- Bearer token auth (optional, via
FUSIONAGI_API_KEY) - Advisory rate limiting (logs, doesn't block)
- Version negotiation via
Accept-Versionheader - SSE streaming for token-by-token responses
- WebSocket for real-time bidirectional communication
- Multi-tenant isolation via
X-Tenant-IDheader - Prometheus metrics at
/metrics(when enabled)
Governance Philosophy
All governance is advisory by default (GovernanceMode.ADVISORY). The system observes, logs, and advises — but does not prevent action. Mistakes are learning opportunities. Every decision, its alternatives, and its consequences are tracked for the ethical learning loop.